1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except 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
16 #include "camera_ndk_unittest.h"
17 #include "camera_log.h"
18 #include "test_common.h"
19 #include "ipc_skeleton.h"
20 #include "access_token.h"
21 #include "hap_token_info.h"
22 #include "accesstoken_kit.h"
23 #include "token_setproc.h"
24 #include "metadata_utils.h"
25 #include "nativetoken_kit.h"
26 #include "surface_utils.h"
27 #include "native_buffer.h"
28 #include "native_image.h"
29 #include "image_kits.h"
30 #include "photo_native_impl.h"
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace CameraStandard {
35 static constexpr int32_t RECEIVER_TEST_WIDTH = 8192;
36 static constexpr int32_t RECEIVER_TEST_HEIGHT = 8;
37 static constexpr int32_t RECEIVER_TEST_CAPACITY = 8;
38 static constexpr int32_t RECEIVER_TEST_FORMAT = 4;
39 static constexpr int32_t CAMERA_DEVICE_INDEX = 0;
CreatePhotoOutput(int32_t width,int32_t height)40 Camera_PhotoOutput* CameraNdkUnitTest::CreatePhotoOutput(int32_t width, int32_t height)
41 {
42 uint32_t photo_width = width;
43 uint32_t photo_height = height;
44 Camera_Format format = (Camera_Format)CAMERA_FORMAT_JPEG;
45 Camera_OutputCapability* OutputCapability = new Camera_OutputCapability;
46 Camera_ErrorCode ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager,
47 cameraDevice, &OutputCapability);
48 EXPECT_EQ(ret, CAMERA_OK);
49 photo_width = OutputCapability->photoProfiles[0]->size.width;
50 photo_height = OutputCapability->photoProfiles[0]->size.height;
51 format = OutputCapability->photoProfiles[0]->format;
52 delete OutputCapability;
53 Camera_Size photoSize = {
54 .width = photo_width,
55 .height = photo_height
56 };
57 Camera_Profile photoProfile = {
58 .format = format,
59 .size = photoSize
60 };
61
62 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
63 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
64 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
65 const char *surfaceId = nullptr;
66 surfaceId = receiverKey.c_str();
67 Camera_PhotoOutput* photoOutput = nullptr;
68 ret = OH_CameraManager_CreatePhotoOutput(cameraManager, &photoProfile, surfaceId, &photoOutput);
69 EXPECT_EQ(ret, CAMERA_OK);
70 EXPECT_NE(photoOutput, nullptr);
71 return photoOutput;
72 }
73
CreatePreviewOutput(int32_t width,int32_t height)74 Camera_PreviewOutput* CameraNdkUnitTest::CreatePreviewOutput(int32_t width, int32_t height)
75 {
76 uint32_t preview_width = width;
77 uint32_t preview_height = height;
78 Camera_Format format = (Camera_Format)CAMERA_FORMAT_RGBA_8888;
79 Camera_OutputCapability* OutputCapability = new Camera_OutputCapability;
80 Camera_ErrorCode ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager,
81 cameraDevice, &OutputCapability);
82 EXPECT_EQ(ret, CAMERA_OK);
83 preview_width = OutputCapability->previewProfiles[0]->size.width;
84 preview_height = OutputCapability->previewProfiles[0]->size.height;
85 format = OutputCapability->previewProfiles[0]->format;
86 delete OutputCapability;
87 Camera_Size previewSize = {
88 .width = preview_width,
89 .height = preview_height
90 };
91 Camera_Profile previewProfile = {
92 .format = format,
93 .size = previewSize
94 };
95 sptr<IConsumerSurface> previewSurface = IConsumerSurface::Create();
96 sptr<IBufferProducer> previewProducer = previewSurface->GetProducer();
97 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(previewProducer);
98 int64_t surfaceIdInt = previewProducer->GetUniqueId();
99 string surfaceIdStr = std::to_string(surfaceIdInt);
100 const char *surfaceId = nullptr;
101 surfaceId = surfaceIdStr.c_str();
102 SurfaceUtils::GetInstance()->Add(surfaceIdInt, pSurface);
103 EXPECT_NE(surfaceId, nullptr);
104 Camera_PreviewOutput* previewOutput = nullptr;
105 ret = OH_CameraManager_CreatePreviewOutput(cameraManager, &previewProfile, surfaceId, &previewOutput);
106 EXPECT_EQ(ret, CAMERA_OK);
107 EXPECT_NE(previewOutput, nullptr);
108 return previewOutput;
109 }
110
CreateVideoOutput(int32_t width,int32_t height)111 Camera_VideoOutput* CameraNdkUnitTest::CreateVideoOutput(int32_t width, int32_t height)
112 {
113 uint32_t video_width = width;
114 uint32_t video_height = height;
115 Camera_Format format = (Camera_Format)CAMERA_FORMAT_RGBA_8888;
116 Camera_OutputCapability* OutputCapability = new Camera_OutputCapability;
117 Camera_ErrorCode ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager,
118 cameraDevice, &OutputCapability);
119 EXPECT_EQ(ret, CAMERA_OK);
120 video_width = OutputCapability->videoProfiles[0]->size.width;
121 video_height = OutputCapability->videoProfiles[0]->size.height;
122 format = OutputCapability->videoProfiles[0]->format;
123 delete OutputCapability;
124 Camera_Size videoSize = {
125 .width = video_width,
126 .height = video_height
127 };
128 Camera_FrameRateRange videoRange = {
129 .min = 30,
130 .max = 30
131 };
132 Camera_VideoProfile videoProfile = {
133 .format = format,
134 .size = videoSize,
135 .range = videoRange
136 };
137 sptr<IConsumerSurface> videoSurface = IConsumerSurface::Create();
138 sptr<IBufferProducer> videoProducer = videoSurface->GetProducer();
139 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(videoProducer);
140 int64_t surfaceIdInt = videoProducer->GetUniqueId();
141 string surfaceIdStr = std::to_string(surfaceIdInt);
142 const char *surfaceId = nullptr;
143 surfaceId = surfaceIdStr.c_str();
144 SurfaceUtils::GetInstance()->Add(surfaceIdInt, pSurface);
145 Camera_VideoOutput* videoOutput = nullptr;
146 ret = OH_CameraManager_CreateVideoOutput(cameraManager, &videoProfile, surfaceId, &videoOutput);
147 EXPECT_EQ(ret, CAMERA_OK);
148 EXPECT_NE(videoOutput, nullptr);
149 return videoOutput;
150 }
151
SessionCommit(Camera_CaptureSession * captureSession)152 void CameraNdkUnitTest::SessionCommit(Camera_CaptureSession *captureSession)
153 {
154 Camera_ErrorCode ret = OH_CaptureSession_CommitConfig(captureSession);
155 EXPECT_EQ(ret, 0);
156 ret = OH_CaptureSession_Start(captureSession);
157 EXPECT_EQ(ret, 0);
158 }
159
SessionControlParams(Camera_CaptureSession * captureSession)160 void CameraNdkUnitTest::SessionControlParams(Camera_CaptureSession *captureSession)
161 {
162 float minZoom = 0.0f, maxZoom = 0.0f;
163 Camera_ErrorCode ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
164 EXPECT_EQ(ret, CAMERA_OK);
165
166 ret = OH_CaptureSession_SetZoomRatio(captureSession, minZoom);
167 EXPECT_EQ(ret, CAMERA_OK);
168 float minExposureBias = 0.0f, maxExposureBias = 0.0f, step = 0.0f;
169 ret = OH_CaptureSession_GetExposureBiasRange(captureSession, &minExposureBias, &maxExposureBias, &step);
170 EXPECT_EQ(ret, CAMERA_OK);
171 ASSERT_NE(minExposureBias, 0.0f);
172 ASSERT_NE(maxExposureBias, 0.0f);
173 ASSERT_NE(step, 0.0f);
174
175 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
176 bool* isSupportedExposureMode = nullptr;
177 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, isSupportedExposureMode);
178 EXPECT_EQ(ret, CAMERA_OK);
179
180 ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias);
181 EXPECT_EQ(ret, CAMERA_OK);
182 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
183 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
184 EXPECT_EQ(ret, CAMERA_OK);
185 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
186 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
187 EXPECT_EQ(ret, CAMERA_OK);
188 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
189 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
190 EXPECT_EQ(ret, CAMERA_OK);
191
192 float zoom = 0.0f;
193 ret = OH_CaptureSession_GetZoomRatio(captureSession, &zoom);
194 EXPECT_EQ(ret, CAMERA_OK);
195 ASSERT_NE(zoom, 0.0f);
196
197 float exposureBias = 0.0f;
198 ret = OH_CaptureSession_GetExposureBias(captureSession, &exposureBias);
199 EXPECT_EQ(ret, CAMERA_OK);
200 ASSERT_NE(exposureBias, 0.0f);
201
202 ret = OH_CaptureSession_GetFlashMode(captureSession, &flash);
203 EXPECT_EQ(ret, CAMERA_OK);
204 EXPECT_EQ(flash, (Camera_FlashMode)FLASH_MODE_ALWAYS_OPEN);
205
206 ret = OH_CaptureSession_GetFocusMode(captureSession, &focus);
207 EXPECT_EQ(ret, CAMERA_OK);
208 EXPECT_EQ(focus, (Camera_FocusMode)FOCUS_MODE_AUTO);
209
210 ret = OH_CaptureSession_GetExposureMode(captureSession, &exposure);
211 EXPECT_EQ(ret, CAMERA_OK);
212 EXPECT_EQ(exposure, (Camera_ExposureMode)EXPOSURE_MODE_AUTO);
213 }
214
SetUpTestCase(void)215 void CameraNdkUnitTest::SetUpTestCase(void) {}
216
TearDownTestCase(void)217 void CameraNdkUnitTest::TearDownTestCase(void) {}
218
SetUp(void)219 void CameraNdkUnitTest::SetUp(void)
220 {
221 // set native token
222 uint64_t tokenId;
223 const char *perms[2];
224 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
225 perms[1] = "ohos.permission.CAMERA";
226 NativeTokenInfoParams infoInstance = {
227 .dcapsNum = 0,
228 .permsNum = 2,
229 .aclsNum = 0,
230 .dcaps = NULL,
231 .perms = perms,
232 .acls = NULL,
233 .processName = "native_camera_tdd",
234 .aplStr = "system_basic",
235 };
236 tokenId = GetAccessTokenId(&infoInstance);
237 SetSelfTokenID(tokenId);
238 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
239
240 Camera_ErrorCode ret = OH_Camera_GetCameraManager(&cameraManager);
241 EXPECT_EQ(ret, 0);
242 ret = OH_CameraManager_GetSupportedCameras(cameraManager, &cameraDevice, &cameraDeviceSize);
243 EXPECT_EQ(ret, 0);
244 }
245
TearDown(void)246 void CameraNdkUnitTest::TearDown(void) {}
247
ReleaseImageReceiver(void)248 void CameraNdkUnitTest::ReleaseImageReceiver(void)
249 {
250 if (imageReceiver != nullptr) {
251 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
252 Media::ImageReceiverManager::ReleaseReceiverById(receiverKey);
253 }
254 }
255
OnCameraInputError(const Camera_Input * cameraInput,Camera_ErrorCode errorCode)256 static void OnCameraInputError(const Camera_Input* cameraInput, Camera_ErrorCode errorCode)
257 {
258 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
259 }
260
CameraCaptureSessiononFocusStateChangeCb(Camera_CaptureSession * session,Camera_FocusState focusState)261 static void CameraCaptureSessiononFocusStateChangeCb(Camera_CaptureSession* session, Camera_FocusState focusState)
262 {
263 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
264 }
265
CameraCaptureSessionOnErrorCb(Camera_CaptureSession * session,Camera_ErrorCode errorCode)266 static void CameraCaptureSessionOnErrorCb(Camera_CaptureSession* session, Camera_ErrorCode errorCode)
267 {
268 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
269 }
270
CameraCaptureSessionOnSmoothZoomInfoCb(Camera_CaptureSession * session,Camera_SmoothZoomInfo * smoothZoomInfo)271 static void CameraCaptureSessionOnSmoothZoomInfoCb(Camera_CaptureSession* session,
272 Camera_SmoothZoomInfo* smoothZoomInfo)
273 {
274 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
275 }
276
CameraManagerOnCameraStatusCb(Camera_Manager * cameraManager,Camera_StatusInfo * status)277 static void CameraManagerOnCameraStatusCb(Camera_Manager* cameraManager, Camera_StatusInfo* status)
278 {
279 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
280 }
281
CameraManagerOnCameraTorchStatusCb(Camera_Manager * cameraManager,Camera_TorchStatusInfo * status)282 static void CameraManagerOnCameraTorchStatusCb(Camera_Manager* cameraManager, Camera_TorchStatusInfo* status)
283 {
284 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
285 }
286
CameraPreviewOutptOnFrameStartCb(Camera_PreviewOutput * previewOutput)287 static void CameraPreviewOutptOnFrameStartCb(Camera_PreviewOutput* previewOutput)
288 {
289 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
290 }
291
CameraPreviewOutptOnFrameEndCb(Camera_PreviewOutput * previewOutput,int32_t frameCount)292 static void CameraPreviewOutptOnFrameEndCb(Camera_PreviewOutput* previewOutput, int32_t frameCount)
293 {
294 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
295 }
296
CameraPreviewOutptOnErrorCb(Camera_PreviewOutput * previewOutput,Camera_ErrorCode errorCode)297 static void CameraPreviewOutptOnErrorCb(Camera_PreviewOutput* previewOutput, Camera_ErrorCode errorCode)
298 {
299 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
300 }
301
CameraPhotoOutptOnFrameStartCb(Camera_PhotoOutput * photoOutput)302 static void CameraPhotoOutptOnFrameStartCb(Camera_PhotoOutput* photoOutput)
303 {
304 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
305 }
306
CameraPhotoOutptOnFrameShutterCb(Camera_PhotoOutput * photoOutput,Camera_FrameShutterInfo * info)307 static void CameraPhotoOutptOnFrameShutterCb(Camera_PhotoOutput* photoOutput, Camera_FrameShutterInfo* info)
308 {
309 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
310 }
311
CameraPhotoOutptOnFrameEndCb(Camera_PhotoOutput * photoOutput,int32_t timestamp)312 static void CameraPhotoOutptOnFrameEndCb(Camera_PhotoOutput* photoOutput, int32_t timestamp)
313 {
314 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
315 }
316
CameraPhotoOutptOnErrorCb(Camera_PhotoOutput * photoOutput,Camera_ErrorCode errorCode)317 static void CameraPhotoOutptOnErrorCb(Camera_PhotoOutput* photoOutput, Camera_ErrorCode errorCode)
318 {
319 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
320 }
321
CameraPhotoOutptOnCaptureEndCb(Camera_PhotoOutput * photoOutput,int32_t frameCount)322 static void CameraPhotoOutptOnCaptureEndCb(Camera_PhotoOutput* photoOutput, int32_t frameCount)
323 {
324 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
325 }
326
CameraPhotoOutptOnCaptureStartWithInfoCb(Camera_PhotoOutput * photoOutput,Camera_CaptureStartInfo * Info)327 static void CameraPhotoOutptOnCaptureStartWithInfoCb(Camera_PhotoOutput* photoOutput, Camera_CaptureStartInfo* Info)
328 {
329 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
330 }
331
CameraPhotoOutptOnFrameShutterEndCb(Camera_PhotoOutput * photoOutput,Camera_FrameShutterInfo * Info)332 static void CameraPhotoOutptOnFrameShutterEndCb(Camera_PhotoOutput* photoOutput, Camera_FrameShutterInfo* Info)
333 {
334 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
335 }
336
CameraPhotoOutptOnCaptureReadyCb(Camera_PhotoOutput * photoOutput)337 static void CameraPhotoOutptOnCaptureReadyCb(Camera_PhotoOutput* photoOutput)
338 {
339 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
340 }
341
CameraPhotoOutptEstimatedOnCaptureDurationCb(Camera_PhotoOutput * photoOutput,int64_t duration)342 static void CameraPhotoOutptEstimatedOnCaptureDurationCb(Camera_PhotoOutput* photoOutput, int64_t duration)
343 {
344 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
345 }
346
CameraPhotoOutptOnPhotoAvailableCb(Camera_PhotoOutput * photoOutput,OH_PhotoNative * photo)347 static void CameraPhotoOutptOnPhotoAvailableCb(Camera_PhotoOutput* photoOutput, OH_PhotoNative* photo)
348 {
349 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
350 }
351
CameraPhotoOutptOnPhotoAssetAvailableCb(Camera_PhotoOutput * photoOutput,OH_MediaAsset * photoAsset)352 static void CameraPhotoOutptOnPhotoAssetAvailableCb(Camera_PhotoOutput* photoOutput, OH_MediaAsset* photoAsset)
353 {
354 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
355 }
356
CameraVideoOutptOnFrameStartCb(Camera_VideoOutput * videoOutput)357 static void CameraVideoOutptOnFrameStartCb(Camera_VideoOutput* videoOutput)
358 {
359 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
360 }
361
CameraVideoOutptOnFrameEndCb(Camera_VideoOutput * videoOutput,int32_t frameCount)362 static void CameraVideoOutptOnFrameEndCb(Camera_VideoOutput* videoOutput, int32_t frameCount)
363 {
364 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
365 }
366
CameraVideoOutptOnErrorCb(Camera_VideoOutput * videoOutput,Camera_ErrorCode errorCode)367 static void CameraVideoOutptOnErrorCb(Camera_VideoOutput* videoOutput, Camera_ErrorCode errorCode)
368 {
369 MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__);
370 }
371
372 /*
373 * Feature: Framework
374 * Function: Test Capture
375 * SubFunction: NA
376 * FunctionPoints: NA
377 * EnvConditions: NA
378 * CaseDescription: Test Capture
379 */
380 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_001, TestSize.Level0)
381 {
382 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
383 EXPECT_NE(photoOutput, nullptr);
384 Camera_CaptureSession* captureSession = nullptr;
385 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
386 EXPECT_EQ(ret, CAMERA_OK);
387 EXPECT_NE(captureSession, nullptr);
388 Camera_Input *cameraInput = nullptr;
389 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
390 EXPECT_EQ(ret, CAMERA_OK);
391 EXPECT_NE(&cameraInput, nullptr);
392 ret = OH_CameraInput_Open(cameraInput);
393 EXPECT_EQ(ret, CAMERA_OK);
394 ret = OH_CaptureSession_BeginConfig(captureSession);
395 EXPECT_EQ(ret, 0);
396 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
397 EXPECT_EQ(ret, 0);
398 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
399 EXPECT_EQ(ret, 0);
400 ret = OH_CaptureSession_CommitConfig(captureSession);
401 EXPECT_EQ(ret, 0);
402 ret = OH_PhotoOutput_Capture(photoOutput);
403 EXPECT_EQ(ret, 0);
404 ret = OH_PhotoOutput_Release(photoOutput);
405 EXPECT_EQ(ret, 0);
406 ret = OH_CameraInput_Release(cameraInput);
407 EXPECT_EQ(ret, 0);
408 ret = OH_CaptureSession_Release(captureSession);
409 EXPECT_EQ(ret, 0);
410 ReleaseImageReceiver();
411 }
412
413 /*
414 * Feature: Framework
415 * Function: Test capture session with commit config multiple times
416 * SubFunction: NA
417 * FunctionPoints: NA
418 * EnvConditions: NA
419 * CaseDescription: Test capture session with commit config multiple times
420 */
421 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_002, TestSize.Level0)
422 {
423 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
424 EXPECT_NE(photoOutput, nullptr);
425 Camera_CaptureSession* captureSession = nullptr;
426 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
427 EXPECT_EQ(ret, CAMERA_OK);
428 EXPECT_NE(captureSession, nullptr);
429
430 Camera_Input *cameraInput = nullptr;
431 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
432 EXPECT_EQ(ret, CAMERA_OK);
433 EXPECT_NE(&cameraInput, nullptr);
434 ret = OH_CameraInput_Open(cameraInput);
435 EXPECT_EQ(ret, CAMERA_OK);
436 ret = OH_CaptureSession_BeginConfig(captureSession);
437 EXPECT_EQ(ret, 0);
438 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
439 EXPECT_EQ(ret, 0);
440 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
441 EXPECT_EQ(ret, 0);
442 ret = OH_CaptureSession_CommitConfig(captureSession);
443 EXPECT_EQ(ret, 0);
444 ret = OH_CaptureSession_CommitConfig(captureSession);
445 EXPECT_NE(ret, 0);
446 ret = OH_PhotoOutput_Release(photoOutput);
447 EXPECT_EQ(ret, 0);
448 ret = OH_CameraInput_Release(cameraInput);
449 EXPECT_EQ(ret, 0);
450 ret = OH_CaptureSession_Release(captureSession);
451 EXPECT_EQ(ret, 0);
452 ReleaseImageReceiver();
453 }
454
455 /*
456 * Feature: Framework
457 * Function: Test create preview output
458 * SubFunction: NA
459 * FunctionPoints: NA
460 * EnvConditions: NA
461 * CaseDescription: Test create preview output
462 */
463 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_004, TestSize.Level0)
464 {
465 Camera_CaptureSession* captureSession = nullptr;
466 Camera_ErrorCode ret = CAMERA_OK;
467 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
468 EXPECT_EQ(ret, CAMERA_OK);
469 EXPECT_NE(captureSession, nullptr);
470 Camera_OutputCapability *OutputCapability = nullptr;
471 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
472 EXPECT_EQ(ret, CAMERA_OK);
473 ret = OH_CaptureSession_BeginConfig(captureSession);
474 EXPECT_EQ(ret, 0);
475
476 Camera_Input *cameraInput = nullptr;
477 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
478 EXPECT_EQ(ret, CAMERA_OK);
479 EXPECT_NE(&cameraInput, nullptr);
480
481 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
482 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
483
484 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
485 EXPECT_NE(previewOutput, nullptr);
486 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
487 EXPECT_EQ(ret, 0);
488
489 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
490
491 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
492 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), 0);
493 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
494 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
495 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
496 }
497
498 /*
499 * Feature: Framework
500 * Function: Test capture session start and stop preview multiple times
501 * SubFunction: NA
502 * FunctionPoints: NA
503 * EnvConditions: NA
504 * CaseDescription: Test capture session start and stop preview multiple times
505 */
506 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_006, TestSize.Level0)
507 {
508 Camera_CaptureSession* captureSession = nullptr;
509 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
510 EXPECT_EQ(ret, CAMERA_OK);
511 EXPECT_NE(captureSession, nullptr);
512 Camera_Input *cameraInput = nullptr;
513 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
514 EXPECT_EQ(ret, CAMERA_OK);
515 ret = OH_CameraInput_Open(cameraInput);
516 EXPECT_EQ(ret, CAMERA_OK);
517
518 EXPECT_NE(&cameraInput, nullptr);
519 ret = OH_CaptureSession_BeginConfig(captureSession);
520 EXPECT_EQ(ret, 0);
521 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
522 EXPECT_EQ(ret, 0);
523
524 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
525 EXPECT_NE(previewOutput, nullptr);
526
527 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
528 EXPECT_EQ(ret, 0);
529
530 ret = OH_CaptureSession_CommitConfig(captureSession);
531 EXPECT_EQ(ret, 0);
532
533 ret = OH_PreviewOutput_Start(previewOutput);
534 EXPECT_EQ(ret, 0);
535 ret = OH_PreviewOutput_Stop(previewOutput);
536 EXPECT_EQ(ret, 0);
537
538 ret = OH_PreviewOutput_Start(previewOutput);
539 EXPECT_EQ(ret, 0);
540 ret = OH_PreviewOutput_Stop(previewOutput);
541 EXPECT_EQ(ret, 0);
542
543 ret = OH_PreviewOutput_Release(previewOutput);
544 EXPECT_EQ(ret, 0);
545 ret = OH_CameraInput_Release(cameraInput);
546 EXPECT_EQ(ret, 0);
547 ret = OH_CaptureSession_Release(captureSession);
548 EXPECT_EQ(ret, 0);
549 }
550
551 /*
552 * Feature: Framework
553 * Function: Test capture session start and stop video multiple times
554 * SubFunction: NA
555 * FunctionPoints: NA
556 * EnvConditions: NA
557 * CaseDescription: Test capture session start and stop video multiple times
558 */
559 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_007, TestSize.Level0)
560 {
561 Camera_CaptureSession* captureSession = nullptr;
562 Camera_ErrorCode ret = CAMERA_OK;
563 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
564 EXPECT_EQ(ret, CAMERA_OK);
565 EXPECT_NE(captureSession, nullptr);
566 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
567 EXPECT_EQ(ret, CAMERA_OK);
568 ret = OH_CaptureSession_BeginConfig(captureSession);
569 EXPECT_EQ(ret, 0);
570 Camera_Input *cameraInput = nullptr;
571 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
572 EXPECT_EQ(ret, CAMERA_OK);
573 EXPECT_NE(cameraInput, nullptr);
574 ret = OH_CameraInput_Open(cameraInput);
575 EXPECT_EQ(ret, CAMERA_OK);
576 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
577 EXPECT_EQ(ret, 0);
578 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
579 EXPECT_NE(previewOutput, nullptr);
580 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
581 EXPECT_EQ(ret, 0);
582 Camera_VideoOutput* videoOutput = CreateVideoOutput();
583 EXPECT_NE(videoOutput, nullptr);
584 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
585 EXPECT_EQ(ret, 0);
586 ret = OH_CaptureSession_CommitConfig(captureSession);
587 EXPECT_EQ(ret, 0);
588 ret = OH_VideoOutput_Start(videoOutput);
589 EXPECT_EQ(ret, 0);
590 ret = OH_VideoOutput_Stop(videoOutput);
591 EXPECT_EQ(ret, 0);
592 ret = OH_VideoOutput_Start(videoOutput);
593 EXPECT_EQ(ret, 0);
594 ret = OH_VideoOutput_Stop(videoOutput);
595 EXPECT_EQ(ret, 0);
596 ret = OH_PreviewOutput_Release(previewOutput);
597 EXPECT_EQ(ret, 0);
598 ret = OH_VideoOutput_Release(videoOutput);
599 EXPECT_EQ(ret, 0);
600 ret = OH_CameraInput_Release(cameraInput);
601 EXPECT_EQ(ret, 0);
602 ret = OH_CaptureSession_Release(captureSession);
603 EXPECT_EQ(ret, 0);
604 }
605
606 /*
607 * Feature: Framework
608 * Function: Test video add preview and photo output, remove photo output, add video output
609 * SubFunction: NA
610 * FunctionPoints: NA
611 * EnvConditions: NA
612 * CaseDescription: Test video add preview and photo output, remove photo output, add video output
613 */
614 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_008, TestSize.Level0)
615 {
616 Camera_CaptureSession* captureSession = nullptr;
617 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
618 EXPECT_EQ(ret, CAMERA_OK);
619 EXPECT_NE(captureSession, nullptr);
620 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
621 EXPECT_EQ(ret, CAMERA_OK);
622 Camera_Input *cameraInput = nullptr;
623 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
624 EXPECT_EQ(ret, CAMERA_OK);
625 EXPECT_NE(&cameraInput, nullptr);
626 ret = OH_CameraInput_Open(cameraInput);
627 EXPECT_EQ(ret, CAMERA_OK);
628 ret = OH_CaptureSession_BeginConfig(captureSession);
629 EXPECT_EQ(ret, 0);
630 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
631 EXPECT_EQ(ret, 0);
632 Camera_VideoOutput* videoOutput = CreateVideoOutput();
633 EXPECT_NE(videoOutput, nullptr);
634 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
635 EXPECT_NE(photoOutput, nullptr);
636 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
637 EXPECT_NE(previewOutput, nullptr);
638 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
639 EXPECT_EQ(ret, 0);
640 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
641 EXPECT_EQ(ret, 0);
642 ret = OH_CaptureSession_RemovePhotoOutput(captureSession, photoOutput);
643 EXPECT_EQ(ret, 0);
644 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
645 EXPECT_EQ(ret, 0);
646 ret = OH_CaptureSession_CommitConfig(captureSession);
647 EXPECT_EQ(ret, 0);
648 ret = OH_VideoOutput_Start(videoOutput);
649 EXPECT_EQ(ret, 0);
650 ret = OH_VideoOutput_Stop(videoOutput);
651 EXPECT_EQ(ret, 0);
652 ret = OH_VideoOutput_Release(videoOutput);
653 EXPECT_EQ(ret, 0);
654 ret = OH_PhotoOutput_Release(photoOutput);
655 EXPECT_EQ(ret, CAMERA_OK);
656 ret = OH_CameraInput_Release(cameraInput);
657 EXPECT_EQ(ret, 0);
658 ret = OH_CaptureSession_Release(captureSession);
659 EXPECT_EQ(ret, 0);
660 ReleaseImageReceiver();
661 }
662
663 /*
664 * Feature: Framework
665 * Function: Test add preview,video and photo output, video start do capture
666 * SubFunction: NA
667 * FunctionPoints: NA
668 * EnvConditions: NA
669 * CaseDescription: Test add preview video and photo output, video start do capture
670 */
671 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_009, TestSize.Level0)
672 {
673 Camera_CaptureSession* captureSession = nullptr;
674 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
675 EXPECT_EQ(ret, CAMERA_OK);
676 EXPECT_NE(captureSession, nullptr);
677 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
678 EXPECT_EQ(ret, CAMERA_OK);
679
680 Camera_Input *cameraInput = nullptr;
681 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
682 EXPECT_EQ(ret, CAMERA_OK);
683 EXPECT_NE(&cameraInput, nullptr);
684
685 ret = OH_CameraInput_Open(cameraInput);
686 EXPECT_EQ(ret, CAMERA_OK);
687
688 ret = OH_CaptureSession_BeginConfig(captureSession);
689 EXPECT_EQ(ret, 0);
690 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
691 EXPECT_EQ(ret, 0);
692
693 Camera_VideoOutput* videoOutput = CreateVideoOutput();
694 EXPECT_NE(videoOutput, nullptr);
695
696 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
697 EXPECT_NE(photoOutput, nullptr);
698
699 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
700 EXPECT_NE(previewOutput, nullptr);
701
702 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
703 EXPECT_EQ(ret, 0);
704
705 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
706 EXPECT_EQ(ret, 0);
707
708 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
709 EXPECT_EQ(ret, 0);
710
711 ret = OH_CaptureSession_CommitConfig(captureSession);
712 EXPECT_EQ(ret, 0);
713
714 ret = OH_VideoOutput_Start(videoOutput);
715 EXPECT_EQ(ret, 0);
716 ret = OH_VideoOutput_Stop(videoOutput);
717 EXPECT_EQ(ret, 0);
718
719 ret = OH_PhotoOutput_Capture(photoOutput);
720 EXPECT_EQ(ret, 0);
721
722 ret = OH_VideoOutput_Release(videoOutput);
723 EXPECT_EQ(ret, 0);
724 ret = OH_PhotoOutput_Release(photoOutput);
725 EXPECT_EQ(ret, CAMERA_OK);
726 ret = OH_CameraInput_Release(cameraInput);
727 EXPECT_EQ(ret, 0);
728 ret = OH_CaptureSession_Release(captureSession);
729 EXPECT_EQ(ret, 0);
730 ReleaseImageReceiver();
731 }
732
733 /*
734 * Feature: Framework
735 * Function: Test add preview and video output, commitconfig remove video Output, add photo output, take photo
736 * SubFunction: NA
737 * FunctionPoints: NA
738 * EnvConditions: NA
739 * CaseDescription: Test add preview and video output, commitconfig remove video Output, add photo output, take photo
740 */
741 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_010, TestSize.Level0)
742 {
743 Camera_CaptureSession* captureSession = nullptr;
744 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
745 EXPECT_EQ(ret, CAMERA_OK);
746 EXPECT_NE(captureSession, nullptr);
747 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
748 EXPECT_EQ(ret, CAMERA_OK);
749
750 Camera_Input *cameraInput = nullptr;
751 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
752 EXPECT_EQ(ret, CAMERA_OK);
753 EXPECT_NE(&cameraInput, nullptr);
754
755 ret = OH_CameraInput_Open(cameraInput);
756 EXPECT_EQ(ret, CAMERA_OK);
757
758 ret = OH_CaptureSession_BeginConfig(captureSession);
759 EXPECT_EQ(ret, 0);
760 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
761 EXPECT_EQ(ret, 0);
762
763 Camera_VideoOutput* videoOutput = CreateVideoOutput();
764 EXPECT_NE(videoOutput, nullptr);
765
766 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
767 EXPECT_NE(previewOutput, nullptr);
768
769 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
770 EXPECT_EQ(ret, 0);
771
772 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
773 EXPECT_EQ(ret, 0);
774
775 ret = OH_CaptureSession_CommitConfig(captureSession);
776 EXPECT_EQ(ret, 0);
777 ret = OH_CaptureSession_BeginConfig(captureSession);
778 EXPECT_EQ(ret, 0);
779 ret = OH_CaptureSession_RemoveVideoOutput(captureSession, videoOutput);
780 EXPECT_EQ(ret, 0);
781 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
782 EXPECT_NE(photoOutput, nullptr);
783 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
784 EXPECT_EQ(ret, 0);
785 ret = OH_CaptureSession_CommitConfig(captureSession);
786 EXPECT_EQ(ret, 0);
787
788 ret = OH_PhotoOutput_Capture(photoOutput);
789 EXPECT_EQ(ret, 0);
790 ret = OH_VideoOutput_Release(videoOutput);
791 EXPECT_EQ(ret, 0);
792 ret = OH_CameraInput_Release(cameraInput);
793 EXPECT_EQ(ret, 0);
794 ret = OH_CaptureSession_Release(captureSession);
795 EXPECT_EQ(ret, 0);
796 ReleaseImageReceiver();
797 }
798
799 /*
800 * Feature: Framework
801 * Function: Test add preview and video output, commitconfig remove video Output
802 * SubFunction: NA
803 * FunctionPoints: NA
804 * EnvConditions: NA
805 * CaseDescription: Test do OH_CaptureSession_BeginConfig/OH_CaptureSession_CommitConfig again
806 */
807 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_013, TestSize.Level0)
808 {
809 Camera_CaptureSession* captureSession = nullptr;
810 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
811 EXPECT_EQ(ret, CAMERA_OK);
812 EXPECT_NE(captureSession, nullptr);
813 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
814 EXPECT_EQ(ret, CAMERA_OK);
815 Camera_Input *cameraInput = nullptr;
816 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
817 EXPECT_EQ(ret, CAMERA_OK);
818 EXPECT_NE(&cameraInput, nullptr);
819 ret = OH_CameraInput_Open(cameraInput);
820 EXPECT_EQ(ret, CAMERA_OK);
821 ret = OH_CaptureSession_BeginConfig(captureSession);
822 EXPECT_EQ(ret, 0);
823 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
824 EXPECT_EQ(ret, 0);
825 Camera_VideoOutput* videoOutput = CreateVideoOutput();
826 EXPECT_NE(videoOutput, nullptr);
827 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
828 EXPECT_NE(previewOutput, nullptr);
829 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
830 EXPECT_EQ(ret, 0);
831 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
832 EXPECT_EQ(ret, 0);
833 ret = OH_CaptureSession_CommitConfig(captureSession);
834 EXPECT_EQ(ret, 0);
835 ret = OH_CaptureSession_BeginConfig(captureSession);
836 EXPECT_EQ(ret, 0);
837
838 ret = OH_CaptureSession_RemoveVideoOutput(captureSession, videoOutput);
839 EXPECT_EQ(ret, 0);
840
841 ret = OH_CaptureSession_CommitConfig(captureSession);
842 EXPECT_EQ(ret, 0);
843 ret = OH_VideoOutput_Release(videoOutput);
844 EXPECT_EQ(ret, 0);
845 ret = OH_CameraInput_Release(cameraInput);
846 EXPECT_EQ(ret, 0);
847 ret = OH_CaptureSession_Release(captureSession);
848 EXPECT_EQ(ret, 0);
849 }
850
851 /*
852 * Feature: Framework
853 * Function: Test add preview and photo output, commitconfig remove photo Output
854 * SubFunction: NA
855 * FunctionPoints: NA
856 * EnvConditions: NA
857 * CaseDescription: Test do OH_CaptureSession_BeginConfig/OH_CaptureSession_CommitConfig again
858 */
859 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_014, TestSize.Level0)
860 {
861 Camera_CaptureSession* captureSession = nullptr;
862 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
863 EXPECT_EQ(ret, CAMERA_OK);
864 EXPECT_NE(captureSession, nullptr);
865 Camera_Input *cameraInput = nullptr;
866 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
867 EXPECT_EQ(ret, CAMERA_OK);
868 EXPECT_NE(&cameraInput, nullptr);
869
870 ret = OH_CameraInput_Open(cameraInput);
871 EXPECT_EQ(ret, CAMERA_OK);
872
873 ret = OH_CaptureSession_BeginConfig(captureSession);
874 EXPECT_EQ(ret, 0);
875 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
876 EXPECT_EQ(ret, 0);
877
878 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
879 EXPECT_NE(photoOutput, nullptr);
880
881 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
882 EXPECT_NE(previewOutput, nullptr);
883
884 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
885 EXPECT_EQ(ret, 0);
886
887 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
888 EXPECT_EQ(ret, 0);
889
890 ret = OH_CaptureSession_CommitConfig(captureSession);
891 EXPECT_EQ(ret, 0);
892
893 ret = OH_CaptureSession_BeginConfig(captureSession);
894 EXPECT_EQ(ret, 0);
895
896 ret = OH_CaptureSession_RemovePreviewOutput(captureSession, previewOutput);
897 EXPECT_EQ(ret, 0);
898
899 ret = OH_CaptureSession_CommitConfig(captureSession);
900 EXPECT_EQ(ret, 0);
901
902 ret = OH_PhotoOutput_Release(photoOutput);
903 EXPECT_EQ(ret, 0);
904 ret = OH_CameraInput_Release(cameraInput);
905 EXPECT_EQ(ret, 0);
906 ret = OH_CaptureSession_Release(captureSession);
907 EXPECT_EQ(ret, 0);
908 ReleaseImageReceiver();
909 }
910
911 /*
912 * Feature: Framework
913 * Function: Test add two preview output and use
914 * SubFunction: NA
915 * FunctionPoints: NA
916 * EnvConditions: NA
917 * CaseDescription: Test add two preview output and use
918 */
919 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_017, TestSize.Level0)
920 {
921 Camera_CaptureSession* captureSession = nullptr;
922 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
923 EXPECT_EQ(ret, CAMERA_OK);
924 EXPECT_NE(captureSession, nullptr);
925
926 Camera_Input *cameraInput = nullptr;
927 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
928 EXPECT_EQ(ret, CAMERA_OK);
929 EXPECT_NE(&cameraInput, nullptr);
930
931 ret = OH_CameraInput_Open(cameraInput);
932 EXPECT_EQ(ret, CAMERA_OK);
933
934 ret = OH_CaptureSession_BeginConfig(captureSession);
935 EXPECT_EQ(ret, 0);
936 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
937 EXPECT_EQ(ret, 0);
938
939 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
940 EXPECT_NE(previewOutput, nullptr);
941 Camera_PreviewOutput* previewOutput2 = CreatePreviewOutput();
942 EXPECT_NE(previewOutput, nullptr);
943
944 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
945 EXPECT_EQ(ret, 0);
946 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput2);
947 EXPECT_EQ(ret, 0);
948
949 ret = OH_CaptureSession_CommitConfig(captureSession);
950 EXPECT_EQ(ret, 0);
951
952 ret = OH_PreviewOutput_Start(previewOutput);
953 EXPECT_EQ(ret, 0);
954 ret = OH_PreviewOutput_Stop(previewOutput);
955 EXPECT_EQ(ret, 0);
956
957 ret = OH_PreviewOutput_Start(previewOutput2);
958 EXPECT_EQ(ret, 0);
959 ret = OH_PreviewOutput_Stop(previewOutput2);
960 EXPECT_EQ(ret, 0);
961 ret = OH_PreviewOutput_Release(previewOutput);
962 EXPECT_EQ(ret, 0);
963 ret = OH_PreviewOutput_Release(previewOutput2);
964 EXPECT_EQ(ret, 0);
965 ret = OH_CameraInput_Release(cameraInput);
966 EXPECT_EQ(ret, 0);
967 ret = OH_CaptureSession_Release(captureSession);
968 EXPECT_EQ(ret, 0);
969 }
970
971 /*
972 * Feature: Framework
973 * Function: Test capture session commit config without adding input
974 * SubFunction: NA
975 * FunctionPoints: NA
976 * EnvConditions: NA
977 * CaseDescription: Test capture session commit config without adding input
978 */
979 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_027, TestSize.Level0)
980 {
981 Camera_CaptureSession* captureSession = nullptr;
982 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
983 EXPECT_EQ(ret, CAMERA_OK);
984 EXPECT_NE(captureSession, nullptr);
985 ret = OH_CaptureSession_BeginConfig(captureSession);
986 EXPECT_EQ(ret, 0);
987 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
988 EXPECT_NE(photoOutput, nullptr);
989 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
990 EXPECT_EQ(ret, 7400201);
991 ret = OH_CaptureSession_CommitConfig(captureSession);
992 EXPECT_NE(ret, 0);
993 ret = OH_CaptureSession_RemovePhotoOutput(captureSession, photoOutput);
994 EXPECT_EQ(ret, 7400201);
995 ret = OH_PhotoOutput_Release(photoOutput);
996 EXPECT_EQ(ret, 0);
997 ret = OH_CaptureSession_Release(captureSession);
998 EXPECT_EQ(ret, 0);
999 ReleaseImageReceiver();
1000 }
1001
1002 /*
1003 * Feature: Framework
1004 * Function: Test capture session commit config without adding output
1005 * SubFunction: NA
1006 * FunctionPoints: NA
1007 * EnvConditions: NA
1008 * CaseDescription: Test capture session commit config without adding output
1009 */
1010 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_028, TestSize.Level0)
1011 {
1012 Camera_Input *cameraInput = nullptr;
1013 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1014 EXPECT_EQ(ret, CAMERA_OK);
1015 EXPECT_NE(&cameraInput, nullptr);
1016 ret = OH_CameraInput_Open(cameraInput);
1017 EXPECT_EQ(ret, CAMERA_OK);
1018 Camera_CaptureSession* captureSession = nullptr;
1019 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1020 EXPECT_EQ(ret, CAMERA_OK);
1021 EXPECT_NE(captureSession, nullptr);
1022 ret = OH_CaptureSession_BeginConfig(captureSession);
1023 EXPECT_EQ(ret, 0);
1024 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1025 EXPECT_EQ(ret, 0);
1026 ret = OH_CaptureSession_CommitConfig(captureSession);
1027 EXPECT_NE(ret, 0);
1028 ret = OH_CaptureSession_RemoveInput(captureSession, cameraInput);
1029 EXPECT_EQ(ret, 0);
1030 ret = OH_CameraInput_Release(cameraInput);
1031 EXPECT_EQ(ret, 0);
1032 ret = OH_CaptureSession_Release(captureSession);
1033 EXPECT_EQ(ret, 0);
1034 }
1035
1036 /*
1037 * Feature: Framework
1038 * Function: Test capture session without begin config
1039 * SubFunction: NA
1040 * FunctionPoints: NA
1041 * EnvConditions: NA
1042 * CaseDescription: Test capture session without begin config
1043 */
1044 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_029, TestSize.Level0)
1045 {
1046 Camera_Input *cameraInput = nullptr;
1047 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1048 EXPECT_EQ(ret, CAMERA_OK);
1049 EXPECT_NE(&cameraInput, nullptr);
1050 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1051 EXPECT_NE(photoOutput, nullptr);
1052 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1053 EXPECT_NE(previewOutput, nullptr);
1054
1055 Camera_CaptureSession* captureSession = nullptr;
1056 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1057 EXPECT_EQ(ret, CAMERA_OK);
1058 EXPECT_NE(captureSession, nullptr);
1059
1060 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1061 EXPECT_NE(ret, 0);
1062
1063 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1064 EXPECT_NE(ret, 0);
1065
1066 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1067 EXPECT_NE(ret, 0);
1068
1069 ret = OH_CaptureSession_CommitConfig(captureSession);
1070 EXPECT_NE(ret, 0);
1071
1072 ret = OH_CaptureSession_Start(captureSession);
1073 EXPECT_NE(ret, 0);
1074
1075 ret = OH_PreviewOutput_Start(previewOutput);
1076 EXPECT_NE(ret, 0);
1077
1078 ret = OH_PhotoOutput_Capture(photoOutput);
1079 EXPECT_NE(ret, 0);
1080
1081 ret = OH_PreviewOutput_Stop(previewOutput);
1082 EXPECT_NE(ret, 0);
1083
1084 ret = OH_CaptureSession_Stop(captureSession);
1085 EXPECT_NE(ret, 0);
1086
1087 ret = OH_CaptureSession_RemovePhotoOutput(captureSession, photoOutput);
1088 EXPECT_NE(ret, 0);
1089
1090 ret = OH_CaptureSession_RemoveInput(captureSession, cameraInput);
1091 EXPECT_NE(ret, 0);
1092
1093 ret = OH_CaptureSession_RemovePreviewOutput(captureSession, previewOutput);
1094 EXPECT_NE(ret, 0);
1095
1096 ret = OH_PreviewOutput_Release(previewOutput);
1097 EXPECT_EQ(ret, 0);
1098 ret = OH_PhotoOutput_Release(photoOutput);
1099 EXPECT_EQ(ret, 0);
1100 ret = OH_CameraInput_Release(cameraInput);
1101 EXPECT_EQ(ret, 0);
1102 ret = OH_CaptureSession_Release(captureSession);
1103 EXPECT_EQ(ret, 0);
1104 ReleaseImageReceiver();
1105 }
1106
1107 /*
1108 * Feature: Framework
1109 * Function: Test capture session start and stop without adding preview output
1110 * SubFunction: NA
1111 * FunctionPoints: NA
1112 * EnvConditions: NA
1113 * CaseDescription: Test capture session start and stop without adding preview output
1114 */
1115 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_030, TestSize.Level0)
1116 {
1117 Camera_Input *cameraInput = nullptr;
1118 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1119 EXPECT_EQ(ret, CAMERA_OK);
1120 EXPECT_NE(&cameraInput, nullptr);
1121 ret = OH_CameraInput_Open(cameraInput);
1122 EXPECT_EQ(ret, CAMERA_OK);
1123 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1124 EXPECT_NE(photoOutput, nullptr);
1125 Camera_CaptureSession* captureSession = nullptr;
1126 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1127 EXPECT_EQ(ret, CAMERA_OK);
1128 EXPECT_NE(captureSession, nullptr);
1129 ret = OH_CaptureSession_BeginConfig(captureSession);
1130 EXPECT_EQ(ret, 0);
1131 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1132 EXPECT_EQ(ret, 0);
1133 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1134 EXPECT_EQ(ret, 0);
1135 ret = OH_CaptureSession_CommitConfig(captureSession);
1136 EXPECT_EQ(ret, 0);
1137 ret = OH_CaptureSession_Start(captureSession);
1138 EXPECT_EQ(ret, 0);
1139 ret = OH_CaptureSession_Stop(captureSession);
1140 EXPECT_EQ(ret, 0);
1141 ret = OH_CameraInput_Release(cameraInput);
1142 EXPECT_EQ(ret, 0);
1143 ret = OH_PhotoOutput_Release(photoOutput);
1144 EXPECT_EQ(ret, 0);
1145 ret = OH_CaptureSession_Release(captureSession);
1146 EXPECT_EQ(ret, 0);
1147 ReleaseImageReceiver();
1148 }
1149
1150 /*
1151 * Feature: Framework
1152 * Function: Test session with preview + photo
1153 * SubFunction: NA
1154 * FunctionPoints: NA
1155 * EnvConditions: NA
1156 * CaseDescription: Test session with preview + photo
1157 */
1158 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_031, TestSize.Level0)
1159 {
1160 Camera_Input *cameraInput = nullptr;
1161 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1162 EXPECT_EQ(ret, CAMERA_OK);
1163 EXPECT_NE(&cameraInput, nullptr);
1164 ret = OH_CameraInput_Open(cameraInput);
1165 EXPECT_EQ(ret, CAMERA_OK);
1166 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1167 EXPECT_NE(photoOutput, nullptr);
1168 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1169 EXPECT_NE(previewOutput, nullptr);
1170 Camera_CaptureSession* captureSession = nullptr;
1171 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1172 EXPECT_EQ(ret, CAMERA_OK);
1173 EXPECT_NE(captureSession, nullptr);
1174 ret = OH_CaptureSession_BeginConfig(captureSession);
1175 EXPECT_EQ(ret, 0);
1176 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1177 EXPECT_EQ(ret, 0);
1178 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1179 EXPECT_EQ(ret, 0);
1180 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1181 EXPECT_EQ(ret, 0);
1182 ret = OH_CaptureSession_CommitConfig(captureSession);
1183 EXPECT_EQ(ret, 0);
1184 ret = OH_CaptureSession_Start(captureSession);
1185 EXPECT_EQ(ret, 0);
1186 ret = OH_PhotoOutput_Capture(photoOutput);
1187 EXPECT_EQ(ret, 0);
1188 ret = OH_PreviewOutput_Stop(previewOutput);
1189 EXPECT_EQ(ret, 0);
1190 ret = OH_CameraInput_Release(cameraInput);
1191 EXPECT_EQ(ret, 0);
1192 ret = OH_PhotoOutput_Release(photoOutput);
1193 EXPECT_EQ(ret, 0);
1194 ret = OH_PreviewOutput_Release(previewOutput);
1195 EXPECT_EQ(ret, 0);
1196 ret = OH_CaptureSession_Release(captureSession);
1197 EXPECT_EQ(ret, 0);
1198 ReleaseImageReceiver();
1199 }
1200
1201 /*
1202 * Feature: Framework
1203 * Function: Test session with preview + video
1204 * SubFunction: NA
1205 * FunctionPoints: NA
1206 * EnvConditions: NA
1207 * CaseDescription: Test session with preview + video
1208 */
1209 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_033, TestSize.Level0)
1210 {
1211 Camera_Input *cameraInput = nullptr;
1212 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1213 EXPECT_EQ(ret, CAMERA_OK);
1214 EXPECT_NE(&cameraInput, nullptr);
1215 ret = OH_CameraInput_Open(cameraInput);
1216 EXPECT_EQ(ret, CAMERA_OK);
1217 Camera_CaptureSession* captureSession = nullptr;
1218 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1219 EXPECT_EQ(ret, CAMERA_OK);
1220 EXPECT_NE(captureSession, nullptr);
1221 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1222 EXPECT_EQ(ret, CAMERA_OK);
1223 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1224 EXPECT_NE(videoOutput, nullptr);
1225 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1226 EXPECT_NE(previewOutput, nullptr);
1227 ret = OH_CaptureSession_BeginConfig(captureSession);
1228 EXPECT_EQ(ret, 0);
1229 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1230 EXPECT_EQ(ret, 0);
1231 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1232 EXPECT_EQ(ret, 0);
1233 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1234 EXPECT_EQ(ret, 0);
1235 ret = OH_CaptureSession_CommitConfig(captureSession);
1236 EXPECT_EQ(ret, 0);
1237 ret = OH_PreviewOutput_Start(previewOutput);
1238 EXPECT_EQ(ret, 0);
1239 sleep(WAIT_TIME_AFTER_START);
1240 ret = OH_VideoOutput_Start(videoOutput);
1241 EXPECT_EQ(ret, 0);
1242 sleep(WAIT_TIME_AFTER_START);
1243 ret = OH_VideoOutput_Stop(videoOutput);
1244 EXPECT_EQ(ret, 0);
1245 ret = OH_PreviewOutput_Stop(previewOutput);
1246 EXPECT_EQ(ret, 0);
1247 ret = OH_VideoOutput_Release(videoOutput);
1248 EXPECT_EQ(ret, 0);
1249 ret = OH_PreviewOutput_Release(previewOutput);
1250 EXPECT_EQ(ret, 0);
1251 ret = OH_CameraInput_Release(cameraInput);
1252 EXPECT_EQ(ret, 0);
1253 ret = OH_CaptureSession_Release(captureSession);
1254 EXPECT_EQ(ret, 0);
1255 }
1256
1257 /*
1258 * Feature: Framework
1259 * Function: Test capture session remove input with null
1260 * SubFunction: NA
1261 * FunctionPoints: NA
1262 * EnvConditions: NA
1263 * CaseDescription: Test capture session remove input with null
1264 */
1265 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_036, TestSize.Level0)
1266 {
1267 Camera_ErrorCode ret = CAMERA_OK;
1268 Camera_Input *cameraInput = nullptr;
1269 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1270 EXPECT_EQ(ret, CAMERA_OK);
1271 EXPECT_NE(&cameraInput, nullptr);
1272 ret = OH_CameraInput_Open(cameraInput);
1273 EXPECT_EQ(ret, CAMERA_OK);
1274 Camera_CaptureSession* captureSession = nullptr;
1275 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1276 EXPECT_EQ(ret, CAMERA_OK);
1277 EXPECT_NE(captureSession, nullptr);
1278 ret = OH_CaptureSession_BeginConfig(captureSession);
1279 EXPECT_EQ(ret, 0);
1280 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1281 EXPECT_EQ(ret, 0);
1282 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1283 EXPECT_NE(previewOutput, nullptr);
1284 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1285 EXPECT_EQ(ret, 0);
1286 OH_CaptureSession_CommitConfig(captureSession);
1287 OH_CaptureSession_Start(captureSession);
1288 Camera_Input *cameraInputNull=nullptr;
1289 ret = OH_CaptureSession_RemoveInput(captureSession, cameraInputNull);
1290 EXPECT_NE(ret, 0);
1291 ret = OH_CaptureSession_Stop(captureSession);
1292 EXPECT_EQ(ret, 0);
1293 ret = OH_PreviewOutput_Release(previewOutput);
1294 EXPECT_EQ(ret, 0);
1295 ret = OH_CaptureSession_Release(captureSession);
1296 EXPECT_EQ(ret, 0);
1297 ret = OH_CameraInput_Release(cameraInput);
1298 EXPECT_EQ(ret, 0);
1299 }
1300
1301 /*
1302 * Feature: Framework
1303 * Function: Test capture session remove input
1304 * SubFunction: NA
1305 * FunctionPoints: NA
1306 * EnvConditions: NA
1307 * CaseDescription: Test capture session remove input
1308 */
1309 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_037, TestSize.Level0)
1310 {
1311 Camera_ErrorCode ret = CAMERA_OK;
1312 Camera_Input *cameraInput = nullptr;
1313 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1314 EXPECT_EQ(ret, CAMERA_OK);
1315 ret = OH_CameraInput_Open(cameraInput);
1316 EXPECT_EQ(ret, CAMERA_OK);
1317 Camera_CaptureSession* captureSession = nullptr;
1318 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1319 EXPECT_EQ(ret, CAMERA_OK);
1320 EXPECT_NE(captureSession, nullptr);
1321 ret = OH_CaptureSession_BeginConfig(captureSession);
1322 EXPECT_EQ(ret, 0);
1323 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1324 EXPECT_EQ(ret, 0);
1325 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1326 EXPECT_NE(previewOutput, nullptr);
1327 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1328 EXPECT_EQ(ret, 0);
1329 ret = OH_CaptureSession_CommitConfig(captureSession);
1330 EXPECT_EQ(ret, 0);
1331 ret = OH_CaptureSession_BeginConfig(captureSession);
1332 EXPECT_EQ(ret, 0);
1333 ret = OH_CaptureSession_RemoveInput(captureSession, cameraInput);
1334 EXPECT_EQ(ret, 0);
1335 ret = OH_PreviewOutput_Release(previewOutput);
1336 EXPECT_EQ(ret, 0);
1337 ret = OH_CaptureSession_Release(captureSession);
1338 EXPECT_EQ(ret, 0);
1339 ret = OH_CameraInput_Release(cameraInput);
1340 EXPECT_EQ(ret, 0);
1341 }
1342
1343 /*
1344 * Feature: Framework
1345 * Function: Test photo capture with photo settings
1346 * SubFunction: NA
1347 * FunctionPoints: NA
1348 * EnvConditions: NA
1349 * CaseDescription: Test photo capture with photo settings
1350 */
1351 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_038, TestSize.Level0)
1352 {
1353 Camera_ErrorCode ret = CAMERA_OK;
1354 Camera_CaptureSession* captureSession = nullptr;
1355 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1356 EXPECT_EQ(ret, CAMERA_OK);
1357 EXPECT_NE(captureSession, nullptr);
1358 Camera_Input *cameraInput = nullptr;
1359 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1360 EXPECT_EQ(ret, CAMERA_OK);
1361 ret = OH_CameraInput_Open(cameraInput);
1362 EXPECT_EQ(ret, CAMERA_OK);
1363 ret = OH_CaptureSession_BeginConfig(captureSession);
1364 EXPECT_EQ(ret, 0);
1365 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1366 EXPECT_EQ(ret, 0);
1367 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1368 EXPECT_NE(PhotoOutput, nullptr);
1369 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1370 EXPECT_EQ(ret, 0);
1371 ret = OH_CaptureSession_CommitConfig(captureSession);
1372 EXPECT_EQ(ret, 0);
1373 Camera_PhotoCaptureSetting capSettings;
1374 capSettings.quality = QUALITY_LEVEL_MEDIUM;
1375 capSettings.rotation = IAMGE_ROTATION_90;
1376 ret = OH_PhotoOutput_Capture_WithCaptureSetting(PhotoOutput, capSettings);
1377 EXPECT_EQ(ret, 0);
1378 OH_CaptureSession_RemovePhotoOutput(captureSession, PhotoOutput);
1379 ret = OH_PhotoOutput_Release(PhotoOutput);
1380 EXPECT_EQ(ret, CAMERA_OK);
1381 ret = OH_CameraInput_Release(cameraInput);
1382 EXPECT_EQ(ret, 0);
1383 ret = OH_CaptureSession_Release(captureSession);
1384 EXPECT_EQ(ret, 0);
1385 ReleaseImageReceiver();
1386 }
1387
1388 /*
1389 * Feature: Framework
1390 * Function: Test SetMeteringPoint & GetMeteringPoint
1391 * SubFunction: NA
1392 * FunctionPoints: NA
1393 * EnvConditions: NA
1394 * CaseDescription: Test SetMeteringPoint & GetMeteringPoint
1395 */
1396 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_041, TestSize.Level0)
1397 {
1398 Camera_ErrorCode ret = CAMERA_OK;
1399 Camera_Input *cameraInput = nullptr;
1400 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1401 EXPECT_EQ(ret, CAMERA_OK);
1402 ret = OH_CameraInput_Open(cameraInput);
1403 EXPECT_EQ(ret, CAMERA_OK);
1404 Camera_CaptureSession* captureSession = nullptr;
1405 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1406 EXPECT_EQ(ret, CAMERA_OK);
1407 EXPECT_NE(captureSession, nullptr);
1408 ret = OH_CaptureSession_BeginConfig(captureSession);
1409 EXPECT_EQ(ret, 0);
1410 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1411 EXPECT_EQ(ret, 0);
1412 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1413 EXPECT_NE(previewOutput, nullptr);
1414
1415 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1416 EXPECT_EQ(ret, 0);
1417 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1418 EXPECT_NE(PhotoOutput, nullptr);
1419 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1420 EXPECT_EQ(ret, 0);
1421 ret = OH_CaptureSession_CommitConfig(captureSession);
1422 EXPECT_EQ(ret, 0);
1423 Camera_Point exposurePointSet = {1.0, 2.0};
1424 ret = OH_CaptureSession_SetMeteringPoint(captureSession, exposurePointSet);
1425 EXPECT_EQ(ret, 0);
1426 Camera_Point exposurePointGet = {0, 0};
1427 ret = OH_CaptureSession_GetMeteringPoint(captureSession, &exposurePointGet);
1428 EXPECT_EQ(ret, 0);
1429 ret = OH_PhotoOutput_Release(PhotoOutput);
1430 EXPECT_EQ(ret, CAMERA_OK);
1431 ret = OH_PreviewOutput_Release(previewOutput);
1432 EXPECT_EQ(ret, 0);
1433 ret = OH_CaptureSession_Release(captureSession);
1434 EXPECT_EQ(ret, 0);
1435 ret = OH_CameraInput_Release(cameraInput);
1436 EXPECT_EQ(ret, 0);
1437 ReleaseImageReceiver();
1438 }
1439
1440 /*
1441 * Feature: Framework
1442 * Function: Test SetFocusPoint & GetFousPoint
1443 * SubFunction: NA
1444 * FunctionPoints: NA
1445 * EnvConditions: NA
1446 * CaseDescription: Test SetFocusPoint & GetFousPoint
1447 */
1448 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_042, TestSize.Level0)
1449 {
1450 Camera_ErrorCode ret = CAMERA_OK;
1451 Camera_Input *cameraInput = nullptr;
1452 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1453 EXPECT_EQ(ret, CAMERA_OK);
1454 ret = OH_CameraInput_Open(cameraInput);
1455 EXPECT_EQ(ret, CAMERA_OK);
1456 Camera_CaptureSession* captureSession = nullptr;
1457 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1458 EXPECT_EQ(ret, CAMERA_OK);
1459 EXPECT_NE(captureSession, nullptr);
1460 ret = OH_CaptureSession_BeginConfig(captureSession);
1461 EXPECT_EQ(ret, 0);
1462 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1463 EXPECT_EQ(ret, 0);
1464 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1465 EXPECT_NE(previewOutput, nullptr);
1466 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1467 EXPECT_EQ(ret, 0);
1468 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1469 EXPECT_NE(PhotoOutput, nullptr);
1470 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1471 EXPECT_EQ(ret, 0);
1472 ret = OH_CaptureSession_CommitConfig(captureSession);
1473 EXPECT_EQ(ret, 0);
1474 Camera_Point FocusPointSet = {1.0, 2.0};
1475 ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet);
1476 EXPECT_EQ(ret, 0);
1477 Camera_Point FocusPointGet = {0, 0};
1478 ret = OH_CaptureSession_GetFocusPoint(captureSession, &FocusPointGet);
1479 EXPECT_EQ(ret, 0);
1480 ret = OH_PhotoOutput_Capture(PhotoOutput);
1481 EXPECT_EQ(ret, 0);
1482 ret = OH_PhotoOutput_Release(PhotoOutput);
1483 EXPECT_EQ(ret, CAMERA_OK);
1484 ret = OH_PreviewOutput_Release(previewOutput);
1485 EXPECT_EQ(ret, 0);
1486 ret = OH_CaptureSession_Release(captureSession);
1487 EXPECT_EQ(ret, 0);
1488 ret = OH_CameraInput_Release(cameraInput);
1489 EXPECT_EQ(ret, 0);
1490 ReleaseImageReceiver();
1491 }
1492
1493 /*
1494 * Feature: Framework
1495 * Function: Test GetExposureValue and SetExposureBias
1496 * SubFunction: NA
1497 * FunctionPoints: NA
1498 * EnvConditions: NA
1499 * CaseDescription: Test GetExposureValue and SetExposureBias with value less then the range
1500 */
1501 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_043, TestSize.Level0)
1502 {
1503 Camera_ErrorCode ret = CAMERA_OK;
1504 Camera_Input *cameraInput = nullptr;
1505 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1506 EXPECT_EQ(ret, CAMERA_OK);
1507 ret = OH_CameraInput_Open(cameraInput);
1508 EXPECT_EQ(ret, CAMERA_OK);
1509 Camera_CaptureSession* captureSession = nullptr;
1510 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1511 EXPECT_EQ(ret, CAMERA_OK);
1512 EXPECT_NE(captureSession, nullptr);
1513 ret = OH_CaptureSession_BeginConfig(captureSession);
1514 EXPECT_EQ(ret, 0);
1515 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1516 EXPECT_EQ(ret, 0);
1517 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1518 EXPECT_NE(previewOutput, nullptr);
1519 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1520 EXPECT_EQ(ret, 0);
1521 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1522 EXPECT_NE(PhotoOutput, nullptr);
1523 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1524 EXPECT_EQ(ret, 0);
1525 ret = OH_CaptureSession_CommitConfig(captureSession);
1526 EXPECT_EQ(ret, 0);
1527 float minExposureBias = 0.0f, maxExposureBias = 0.0f, step = 0.0f;
1528 ret = OH_CaptureSession_GetExposureBiasRange(captureSession, &minExposureBias, &maxExposureBias, &step);
1529 EXPECT_EQ(ret, CAMERA_OK);
1530 ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias-1.0);
1531 EXPECT_EQ(ret, CAMERA_OK);
1532 ret = OH_PhotoOutput_Capture(PhotoOutput);
1533 EXPECT_EQ(ret, 0);
1534 ret = OH_PhotoOutput_Release(PhotoOutput);
1535 EXPECT_EQ(ret, CAMERA_OK);
1536 ret = OH_PreviewOutput_Release(previewOutput);
1537 EXPECT_EQ(ret, 0);
1538 ret = OH_CaptureSession_Release(captureSession);
1539 EXPECT_EQ(ret, 0);
1540 ret = OH_CameraInput_Release(cameraInput);
1541 EXPECT_EQ(ret, 0);
1542 ReleaseImageReceiver();
1543 }
1544
1545 /*
1546 * Feature: Framework
1547 * Function: Test GetExposureValue and SetExposureBias
1548 * SubFunction: NA
1549 * FunctionPoints: NA
1550 * EnvConditions: NA
1551 * CaseDescription: Test GetExposureValue and SetExposureBias with value between the range
1552 */
1553 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_044, TestSize.Level0)
1554 {
1555 Camera_ErrorCode ret = CAMERA_OK;
1556 Camera_Input *cameraInput = nullptr;
1557 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1558 EXPECT_EQ(ret, CAMERA_OK);
1559 ret = OH_CameraInput_Open(cameraInput);
1560 EXPECT_EQ(ret, CAMERA_OK);
1561 Camera_CaptureSession* captureSession = nullptr;
1562 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1563 EXPECT_EQ(ret, CAMERA_OK);
1564 EXPECT_NE(captureSession, nullptr);
1565 ret = OH_CaptureSession_BeginConfig(captureSession);
1566 EXPECT_EQ(ret, 0);
1567 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1568 EXPECT_EQ(ret, 0);
1569 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1570 EXPECT_NE(previewOutput, nullptr);
1571 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1572 EXPECT_EQ(ret, 0);
1573 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1574 EXPECT_NE(PhotoOutput, nullptr);
1575 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1576 EXPECT_EQ(ret, 0);
1577 ret = OH_CaptureSession_CommitConfig(captureSession);
1578 EXPECT_EQ(ret, 0);
1579 float minExposureBias = 0.0f, maxExposureBias = 0.0f, step = 0.0f;
1580 ret = OH_CaptureSession_GetExposureBiasRange(captureSession, &minExposureBias, &maxExposureBias, &step);
1581 EXPECT_EQ(ret, CAMERA_OK);
1582 ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias+1.0);
1583 EXPECT_EQ(ret, CAMERA_OK);
1584 ret = OH_PhotoOutput_Capture(PhotoOutput);
1585 EXPECT_EQ(ret, 0);
1586 ret = OH_PhotoOutput_Release(PhotoOutput);
1587 EXPECT_EQ(ret, CAMERA_OK);
1588 ret = OH_PreviewOutput_Release(previewOutput);
1589 EXPECT_EQ(ret, 0);
1590 ret = OH_CaptureSession_Release(captureSession);
1591 EXPECT_EQ(ret, 0);
1592 ret = OH_CameraInput_Release(cameraInput);
1593 EXPECT_EQ(ret, 0);
1594 ReleaseImageReceiver();
1595 }
1596
1597 /*
1598 * Feature: Framework
1599 * Function: Test GetExposureValue and SetExposureBias
1600 * SubFunction: NA
1601 * FunctionPoints: NA
1602 * EnvConditions: NA
1603 * CaseDescription: Test GetExposureValue and SetExposureBias with value more then the range
1604 */
1605 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_045, TestSize.Level0)
1606 {
1607 Camera_ErrorCode ret = CAMERA_OK;
1608 Camera_Input *cameraInput = nullptr;
1609 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1610 EXPECT_EQ(ret, CAMERA_OK);
1611 ret = OH_CameraInput_Open(cameraInput);
1612 EXPECT_EQ(ret, CAMERA_OK);
1613 Camera_CaptureSession* captureSession = nullptr;
1614 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1615 EXPECT_EQ(ret, CAMERA_OK);
1616 EXPECT_NE(captureSession, nullptr);
1617 ret = OH_CaptureSession_BeginConfig(captureSession);
1618 EXPECT_EQ(ret, 0);
1619 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1620 EXPECT_EQ(ret, 0);
1621 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1622 EXPECT_NE(previewOutput, nullptr);
1623 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1624 EXPECT_EQ(ret, 0);
1625 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1626 EXPECT_NE(PhotoOutput, nullptr);
1627 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1628 EXPECT_EQ(ret, 0);
1629 ret = OH_CaptureSession_CommitConfig(captureSession);
1630 EXPECT_EQ(ret, 0);
1631 float minExposureBias = 0.0f, maxExposureBias = 0.0f, step = 0.0f;
1632 ret = OH_CaptureSession_GetExposureBiasRange(captureSession, &minExposureBias, &maxExposureBias, &step);
1633 EXPECT_EQ(ret, CAMERA_OK);
1634 ret = OH_CaptureSession_SetExposureBias(captureSession, maxExposureBias+1.0);
1635 EXPECT_EQ(ret, CAMERA_OK);
1636 ret = OH_PhotoOutput_Capture(PhotoOutput);
1637 EXPECT_EQ(ret, 0);
1638 ret = OH_PhotoOutput_Release(PhotoOutput);
1639 EXPECT_EQ(ret, CAMERA_OK);
1640 ret = OH_PreviewOutput_Release(previewOutput);
1641 EXPECT_EQ(ret, 0);
1642 ret = OH_CaptureSession_Release(captureSession);
1643 EXPECT_EQ(ret, 0);
1644 ret = OH_CameraInput_Release(cameraInput);
1645 EXPECT_EQ(ret, 0);
1646 ReleaseImageReceiver();
1647 }
1648
1649 /*
1650 * Feature: Framework
1651 * Function: Test photo capture with capture settings
1652 * SubFunction: NA
1653 * FunctionPoints: NA
1654 * EnvConditions: NA
1655 * CaseDescription: Test photo capture with preview output & capture settings
1656 */
1657 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_054, TestSize.Level0)
1658 {
1659 Camera_ErrorCode ret = CAMERA_OK;
1660 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1661 EXPECT_NE(PhotoOutput, nullptr);
1662 Camera_CaptureSession* captureSession = nullptr;
1663 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1664 EXPECT_EQ(ret, CAMERA_OK);
1665 EXPECT_NE(captureSession, nullptr);
1666 Camera_Input *cameraInput = nullptr;
1667 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1668 EXPECT_EQ(ret, CAMERA_OK);
1669 ret = OH_CameraInput_Open(cameraInput);
1670 EXPECT_EQ(ret, CAMERA_OK);
1671 ret = OH_CaptureSession_BeginConfig(captureSession);
1672 EXPECT_EQ(ret, 0);
1673 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1674 EXPECT_NE(previewOutput, nullptr);
1675 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1676 EXPECT_EQ(ret, 0);
1677 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1678 EXPECT_EQ(ret, 0);
1679 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1680 EXPECT_EQ(ret, 0);
1681 ret = OH_CaptureSession_CommitConfig(captureSession);
1682 EXPECT_EQ(ret, 0);
1683 Camera_PhotoCaptureSetting capSettings;
1684 capSettings.quality = QUALITY_LEVEL_MEDIUM;
1685 capSettings.rotation = IAMGE_ROTATION_90;
1686 ret = OH_PhotoOutput_Capture_WithCaptureSetting(PhotoOutput, capSettings);
1687 EXPECT_EQ(ret, 0);
1688 ret = OH_PhotoOutput_Release(PhotoOutput);
1689 EXPECT_EQ(ret, 0);
1690 ret = OH_PreviewOutput_Release(previewOutput);
1691 EXPECT_EQ(ret, 0);
1692 ret = OH_CameraInput_Release(cameraInput);
1693 EXPECT_EQ(ret, 0);
1694 ret = OH_CaptureSession_Release(captureSession);
1695 EXPECT_EQ(ret, 0);
1696 ReleaseImageReceiver();
1697 }
1698
1699 /*
1700 * Feature: Framework
1701 * Function: Test capture session with Video Stabilization Mode
1702 * SubFunction: NA
1703 * FunctionPoints: NA
1704 * EnvConditions: NA
1705 * CaseDescription: Test capture session with Video Stabilization Mode
1706 */
1707 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_057, TestSize.Level0)
1708 {
1709 Camera_CaptureSession* captureSession;
1710 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1711 EXPECT_EQ(ret, CAMERA_OK);
1712 EXPECT_NE(captureSession, nullptr);
1713 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1714 EXPECT_EQ(ret, CAMERA_OK);
1715
1716 Camera_Input *cameraInput;
1717 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1718 EXPECT_EQ(ret, CAMERA_OK);
1719 ret = OH_CameraInput_Open(cameraInput);
1720 EXPECT_EQ(ret, CAMERA_OK);
1721 ret = OH_CaptureSession_BeginConfig(captureSession);
1722 EXPECT_EQ(ret, 0);
1723 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1724 EXPECT_EQ(ret, 0);
1725 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1726 EXPECT_NE(previewOutput, nullptr);
1727 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1728 EXPECT_EQ(ret, 0);
1729 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1730 EXPECT_NE(videoOutput, nullptr);
1731 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1732 EXPECT_EQ(ret, 0);
1733 ret = OH_CaptureSession_CommitConfig(captureSession);
1734 EXPECT_EQ(ret, 0);
1735 ret = OH_PreviewOutput_Start(previewOutput);
1736 EXPECT_EQ(ret, 0);
1737 bool isSupported=false;
1738 ret = OH_CaptureSession_IsVideoStabilizationModeSupported(captureSession, STABILIZATION_MODE_MIDDLE, &isSupported);
1739
1740 if (isSupported) {
1741 ret = OH_CaptureSession_SetVideoStabilizationMode(captureSession, STABILIZATION_MODE_MIDDLE);
1742 EXPECT_EQ(ret, 0);
1743 }
1744 ret = OH_VideoOutput_Start(videoOutput);
1745 EXPECT_EQ(ret, 0);
1746 sleep(WAIT_TIME_AFTER_START);
1747 ret = OH_VideoOutput_Stop(videoOutput);
1748 EXPECT_EQ(ret, 0);
1749 ret = OH_VideoOutput_Release(videoOutput);
1750 EXPECT_EQ(ret, 0);
1751 ret = OH_PreviewOutput_Stop(previewOutput);
1752 EXPECT_EQ(ret, 0);
1753 ret = OH_PreviewOutput_Release(previewOutput);
1754 EXPECT_EQ(ret, 0);
1755 ret = OH_CameraInput_Release(cameraInput);
1756 EXPECT_EQ(ret, 0);
1757 ret = OH_CaptureSession_Release(captureSession);
1758 EXPECT_EQ(ret, 0);
1759 }
1760
1761 /*
1762 * Feature: Framework
1763 * Function: Test add preview,video and photo output,set location,video start do capture
1764 * SubFunction: NA
1765 * FunctionPoints: NA
1766 * EnvConditions: NA
1767 * CaseDescription: Test add preview video and photo output, video start do capture
1768 */
1769 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_058, TestSize.Level0)
1770 {
1771 Camera_CaptureSession* captureSession = nullptr;
1772 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1773 EXPECT_EQ(ret, CAMERA_OK);
1774 EXPECT_NE(captureSession, nullptr);
1775 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1776 EXPECT_EQ(ret, CAMERA_OK);
1777 Camera_Input *cameraInput = nullptr;
1778 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1779 EXPECT_EQ(ret, CAMERA_OK);
1780 ret = OH_CameraInput_Open(cameraInput);
1781 EXPECT_EQ(ret, CAMERA_OK);
1782 EXPECT_NE(&cameraInput, nullptr);
1783 ret = OH_CaptureSession_BeginConfig(captureSession);
1784 EXPECT_EQ(ret, 0);
1785 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1786 EXPECT_EQ(ret, 0);
1787 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1788 EXPECT_NE(videoOutput, nullptr);
1789 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1790 EXPECT_NE(photoOutput, nullptr);
1791 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1792 EXPECT_NE(previewOutput, nullptr);
1793 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1794 EXPECT_EQ(ret, 0);
1795 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1796 EXPECT_EQ(ret, 0);
1797 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1798 EXPECT_EQ(ret, 0);
1799 ret = OH_CaptureSession_CommitConfig(captureSession);
1800 EXPECT_EQ(ret, 0);
1801 ret = OH_VideoOutput_Start(videoOutput);
1802 EXPECT_EQ(ret, 0);
1803
1804 Camera_PhotoCaptureSetting capSettings;
1805 capSettings.quality = QUALITY_LEVEL_MEDIUM;
1806
1807 Camera_Location location = {1.0, 1.0, 1.0};
1808 capSettings.location = &location;
1809 ret = OH_PhotoOutput_Capture_WithCaptureSetting(photoOutput, capSettings);
1810 EXPECT_EQ(ret, 0);
1811
1812 ret = OH_VideoOutput_Stop(videoOutput);
1813 EXPECT_EQ(ret, 0);
1814 ret = OH_VideoOutput_Release(videoOutput);
1815 EXPECT_EQ(ret, 0);
1816 ret = OH_PhotoOutput_Release(photoOutput);
1817 EXPECT_EQ(ret, CAMERA_OK);
1818 ret = OH_CameraInput_Release(cameraInput);
1819 EXPECT_EQ(ret, 0);
1820 ret = OH_CaptureSession_Release(captureSession);
1821 EXPECT_EQ(ret, 0);
1822 ReleaseImageReceiver();
1823 }
1824
1825 /*
1826 * Feature: Framework
1827 * Function: Test add preview,video and photo output, set mirror,video start do capture
1828 * SubFunction: NA
1829 * FunctionPoints: NA
1830 * EnvConditions: NA
1831 * CaseDescription: Test add preview video and photo output, video start do capture
1832 */
1833 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_059, TestSize.Level0)
1834 {
1835 Camera_CaptureSession* captureSession = nullptr;
1836 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1837 EXPECT_EQ(ret, CAMERA_OK);
1838 EXPECT_NE(captureSession, nullptr);
1839 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1840 EXPECT_EQ(ret, CAMERA_OK);
1841 Camera_Input *cameraInput = nullptr;
1842 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1843 EXPECT_EQ(ret, CAMERA_OK);
1844 ret = OH_CameraInput_Open(cameraInput);
1845 EXPECT_EQ(ret, CAMERA_OK);
1846 EXPECT_NE(&cameraInput, nullptr);
1847 ret = OH_CaptureSession_BeginConfig(captureSession);
1848 EXPECT_EQ(ret, 0);
1849 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1850 EXPECT_EQ(ret, 0);
1851 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1852 EXPECT_NE(videoOutput, nullptr);
1853 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1854 EXPECT_NE(photoOutput, nullptr);
1855 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1856 EXPECT_NE(previewOutput, nullptr);
1857 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1858 EXPECT_EQ(ret, 0);
1859 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1860 EXPECT_EQ(ret, 0);
1861 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1862 EXPECT_EQ(ret, 0);
1863 ret = OH_CaptureSession_CommitConfig(captureSession);
1864 EXPECT_EQ(ret, 0);
1865 ret = OH_VideoOutput_Start(videoOutput);
1866 EXPECT_EQ(ret, 0);
1867 Camera_PhotoCaptureSetting capSettings;
1868 capSettings.mirror = true;
1869 ret = OH_PhotoOutput_Capture_WithCaptureSetting(photoOutput, capSettings);
1870 EXPECT_EQ(ret, 0);
1871 ret = OH_VideoOutput_Stop(videoOutput);
1872 EXPECT_EQ(ret, 0);
1873 ret = OH_VideoOutput_Release(videoOutput);
1874 EXPECT_EQ(ret, 0);
1875 ret = OH_PhotoOutput_Release(photoOutput);
1876 EXPECT_EQ(ret, CAMERA_OK);
1877 ret = OH_CameraInput_Release(cameraInput);
1878 EXPECT_EQ(ret, 0);
1879 ret = OH_CaptureSession_Release(captureSession);
1880 EXPECT_EQ(ret, 0);
1881 ReleaseImageReceiver();
1882 }
1883
1884 /*
1885 * Feature: Framework
1886 * Function: Test open flash preview capture video callback
1887 * SubFunction: NA
1888 * FunctionPoints: NA
1889 * EnvConditions: NA
1890 * CaseDescription: Test open flash preview capture video callback
1891 */
1892 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_061, TestSize.Level0)
1893 {
1894 Camera_ErrorCode ret = CAMERA_OK;
1895 Camera_CaptureSession* captureSession = nullptr;
1896 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
1897 EXPECT_NE(captureSession, nullptr);
1898 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1899 EXPECT_EQ(ret, CAMERA_OK);
1900
1901 Camera_Input *cameraInput = nullptr;
1902 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1903 EXPECT_EQ(ret, CAMERA_OK);
1904
1905 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
1906 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
1907
1908 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_OPEN);
1909 bool isSupported = false;
1910 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
1911 EXPECT_EQ(ret, 0);
1912
1913 if (isSupported) {
1914 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
1915 }
1916 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1917 EXPECT_EQ(ret, 0);
1918 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1919 EXPECT_NE(previewOutput, nullptr);
1920 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1921 EXPECT_EQ(ret, 0);
1922 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1923 EXPECT_NE(PhotoOutput, nullptr);
1924
1925 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1926 EXPECT_EQ(ret, 0);
1927 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1928 EXPECT_NE(videoOutput, nullptr);
1929 VideoOutput_Callbacks setVideoResultCallback = {
1930 .onFrameStart = &CameraVideoOutptOnFrameStartCb,
1931 .onFrameEnd = &CameraVideoOutptOnFrameEndCb,
1932 .onError = &CameraVideoOutptOnErrorCb
1933 };
1934 ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback);
1935 EXPECT_EQ(ret, CAMERA_OK);
1936 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0);
1937 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
1938 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
1939 EXPECT_EQ(OH_VideoOutput_UnregisterCallback(videoOutput, &setVideoResultCallback), 0);
1940
1941 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0);
1942 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
1943 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
1944 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
1945 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
1946 ReleaseImageReceiver();
1947 }
1948
1949 /*
1950 * Feature: Framework
1951 * Function: Test close flash preview capture video callback
1952 * SubFunction: NA
1953 * FunctionPoints: NA
1954 * EnvConditions: NA
1955 * CaseDescription: Test close flash preview capture video callback
1956 */
1957 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_065, TestSize.Level0)
1958 {
1959 Camera_ErrorCode ret = CAMERA_OK;
1960 Camera_CaptureSession* captureSession = nullptr;
1961 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
1962 EXPECT_NE(captureSession, nullptr);
1963 Camera_Input *cameraInput = nullptr;
1964 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1965 EXPECT_EQ(ret, CAMERA_OK);
1966 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
1967 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
1968 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_OPEN);
1969 bool isSupported = false;
1970 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
1971 EXPECT_EQ(ret, 0);
1972 if (isSupported) {
1973 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
1974 }
1975 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1976 EXPECT_EQ(ret, 0);
1977 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1978 EXPECT_NE(previewOutput, nullptr);
1979
1980 PreviewOutput_Callbacks setPreviewResultCallback = {
1981 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
1982 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
1983 .onError = &CameraPreviewOutptOnErrorCb
1984 };
1985
1986 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
1987 EXPECT_EQ(ret, CAMERA_OK);
1988 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1989 EXPECT_EQ(ret, 0);
1990 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
1991 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
1992 EXPECT_EQ(OH_PreviewOutput_UnregisterCallback(previewOutput, &setPreviewResultCallback), 0);
1993 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
1994 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
1995 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
1996 }
1997
1998 /*
1999 * Feature: Framework
2000 * Function: Test close flash preview capture video callback
2001 * SubFunction: NA
2002 * FunctionPoints: NA
2003 * EnvConditions: NA
2004 * CaseDescription: Test close flash preview capture video callback
2005 */
2006 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_066, TestSize.Level0)
2007 {
2008 Camera_ErrorCode ret = CAMERA_OK;
2009 Camera_CaptureSession* captureSession = nullptr;
2010 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2011 EXPECT_NE(captureSession, nullptr);
2012 Camera_Input *cameraInput = nullptr;
2013 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2014 EXPECT_EQ(ret, CAMERA_OK);
2015 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2016 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2017 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_OPEN);
2018 bool isSupported = false;
2019 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2020 EXPECT_EQ(ret, 0);
2021 if (isSupported) {
2022 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2023 }
2024 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2025 EXPECT_EQ(ret, 0);
2026 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2027 EXPECT_NE(previewOutput, nullptr);
2028 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2029 EXPECT_EQ(ret, 0);
2030 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
2031 EXPECT_NE(PhotoOutput, nullptr);
2032 PhotoOutput_Callbacks setPhotoOutputResultCallback = {
2033 .onFrameStart = &CameraPhotoOutptOnFrameStartCb,
2034 .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb,
2035 .onFrameEnd = &CameraPhotoOutptOnFrameEndCb,
2036 .onError = &CameraPhotoOutptOnErrorCb
2037 };
2038 ret = OH_PhotoOutput_RegisterCallback(PhotoOutput, &setPhotoOutputResultCallback);
2039 EXPECT_EQ(ret, CAMERA_OK);
2040 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
2041 EXPECT_EQ(ret, 0);
2042 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2043 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2044 EXPECT_EQ(OH_PhotoOutput_Capture(PhotoOutput), 0);
2045 EXPECT_EQ(OH_PhotoOutput_UnregisterCallback(PhotoOutput, &setPhotoOutputResultCallback), 0);
2046 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2047 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2048 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2049 ReleaseImageReceiver();
2050 }
2051
2052 /*
2053 * Feature: Framework
2054 * Function: Test close flash preview capture video callback
2055 * SubFunction: NA
2056 * FunctionPoints: NA
2057 * EnvConditions: NA
2058 * CaseDescription: Test close flash preview capture video callback
2059 */
2060 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_062, TestSize.Level0)
2061 {
2062 Camera_ErrorCode ret = CAMERA_OK;
2063 Camera_CaptureSession* captureSession = nullptr;
2064 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2065 EXPECT_NE(captureSession, nullptr);
2066 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
2067 EXPECT_EQ(ret, CAMERA_OK);
2068 Camera_Input *cameraInput = nullptr;
2069 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2070 EXPECT_EQ(ret, CAMERA_OK);
2071 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2072 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2073 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_CLOSE);
2074 bool isSupported = false;
2075 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2076 EXPECT_EQ(ret, 0);
2077 if (isSupported) {
2078 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2079 }
2080 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2081 EXPECT_EQ(ret, 0);
2082 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2083 EXPECT_NE(previewOutput, nullptr);
2084 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2085 EXPECT_EQ(ret, 0);
2086 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
2087 EXPECT_NE(PhotoOutput, nullptr);
2088
2089 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
2090 EXPECT_EQ(ret, 0);
2091 Camera_VideoOutput* videoOutput = CreateVideoOutput();
2092 EXPECT_NE(videoOutput, nullptr);
2093 VideoOutput_Callbacks setVideoResultCallback = {
2094 .onFrameStart = &CameraVideoOutptOnFrameStartCb,
2095 .onFrameEnd = &CameraVideoOutptOnFrameEndCb,
2096 .onError = &CameraVideoOutptOnErrorCb
2097 };
2098 ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback);
2099 EXPECT_EQ(ret, CAMERA_OK);
2100 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0);
2101 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2102 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2103 EXPECT_EQ(OH_VideoOutput_UnregisterCallback(videoOutput, &setVideoResultCallback), 0);
2104
2105 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0);
2106 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2107 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2108 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2109 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2110 ReleaseImageReceiver();
2111 }
2112
2113 /*
2114 * Feature: Framework
2115 * Function: Test close flash preview capture video callback
2116 * SubFunction: NA
2117 * FunctionPoints: NA
2118 * EnvConditions: NA
2119 * CaseDescription: Test close flash preview capture video callback
2120 */
2121 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_063, TestSize.Level0)
2122 {
2123 Camera_ErrorCode ret = CAMERA_OK;
2124 Camera_CaptureSession* captureSession = nullptr;
2125 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2126 EXPECT_NE(captureSession, nullptr);
2127 Camera_Input *cameraInput = nullptr;
2128 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2129 EXPECT_EQ(ret, CAMERA_OK);
2130 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2131 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2132 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_CLOSE);
2133 bool isSupported = false;
2134 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2135 EXPECT_EQ(ret, 0);
2136 if (isSupported) {
2137 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2138 }
2139 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2140 EXPECT_EQ(ret, 0);
2141 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2142 EXPECT_NE(previewOutput, nullptr);
2143
2144 PreviewOutput_Callbacks setPreviewResultCallback = {
2145 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2146 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2147 .onError = &CameraPreviewOutptOnErrorCb
2148 };
2149
2150 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2151 EXPECT_EQ(ret, CAMERA_OK);
2152 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2153 EXPECT_EQ(ret, 0);
2154 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2155 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2156 EXPECT_EQ(OH_PreviewOutput_UnregisterCallback(previewOutput, &setPreviewResultCallback), 0);
2157 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2158 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2159 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2160 }
2161
2162 /*
2163 * Feature: Framework
2164 * Function: Test close flash preview capture video callback
2165 * SubFunction: NA
2166 * FunctionPoints: NA
2167 * EnvConditions: NA
2168 * CaseDescription: Test close flash preview capture video callback
2169 */
2170 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_064, TestSize.Level0)
2171 {
2172 Camera_ErrorCode ret = CAMERA_OK;
2173 Camera_CaptureSession* captureSession = nullptr;
2174 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2175 EXPECT_NE(captureSession, nullptr);
2176 Camera_Input *cameraInput = nullptr;
2177 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2178 EXPECT_EQ(ret, CAMERA_OK);
2179 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2180 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2181 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_CLOSE);
2182 bool isSupported = false;
2183 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2184 EXPECT_EQ(ret, 0);
2185 if (isSupported) {
2186 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2187 }
2188 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2189 EXPECT_EQ(ret, 0);
2190 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2191 EXPECT_NE(previewOutput, nullptr);
2192 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2193 EXPECT_EQ(ret, 0);
2194 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
2195 EXPECT_NE(PhotoOutput, nullptr);
2196 PhotoOutput_Callbacks setPhotoOutputResultCallback = {
2197 .onFrameStart = &CameraPhotoOutptOnFrameStartCb,
2198 .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb,
2199 .onFrameEnd = &CameraPhotoOutptOnFrameEndCb,
2200 .onError = &CameraPhotoOutptOnErrorCb
2201 };
2202 ret = OH_PhotoOutput_RegisterCallback(PhotoOutput, &setPhotoOutputResultCallback);
2203 EXPECT_EQ(ret, CAMERA_OK);
2204 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
2205 EXPECT_EQ(ret, 0);
2206 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2207 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2208 EXPECT_EQ(OH_PhotoOutput_Capture(PhotoOutput), 0);
2209 EXPECT_EQ(OH_PhotoOutput_UnregisterCallback(PhotoOutput, &setPhotoOutputResultCallback), 0);
2210 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2211 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2212 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2213 ReleaseImageReceiver();
2214 }
2215
2216
2217 /*
2218 * Feature: Framework
2219 * Function: Test cameramanager delete supported cameras, output capability and manager
2220 * SubFunction: NA
2221 * FunctionPoints: NA
2222 * EnvConditions: NA
2223 * CaseDescription: Test cameramanager delete supported cameras, output capability and manager
2224 */
2225 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_002, TestSize.Level0)
2226 {
2227 Camera_ErrorCode ret = CAMERA_OK;
2228 Camera_CaptureSession* captureSession = nullptr;
2229 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2230 EXPECT_EQ(ret, CAMERA_OK);
2231 EXPECT_NE(captureSession, nullptr);
2232 Camera_OutputCapability *OutputCapability = nullptr;
2233
2234 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
2235 EXPECT_EQ(ret, CAMERA_OK);
2236
2237 ret = OH_CameraManager_DeleteSupportedCameras(cameraManager, cameraDevice, cameraDeviceSize);
2238 EXPECT_EQ(ret, 0);
2239
2240 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2241 EXPECT_EQ(ret, 0);
2242
2243 ret = OH_Camera_DeleteCameraManager(cameraManager);
2244 EXPECT_EQ(ret, 0);
2245 }
2246
2247 /*
2248 * Feature: Framework
2249 * Function: Test cameramanager delete supported without profiles
2250 * SubFunction: NA
2251 * FunctionPoints: NA
2252 * EnvConditions: NA
2253 * CaseDescription: Test cameramanager delete supported without profiles
2254 */
2255 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_004, TestSize.Level0)
2256 {
2257 Camera_ErrorCode ret = CAMERA_OK;
2258 Camera_CaptureSession* captureSession = nullptr;
2259 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2260 EXPECT_EQ(ret, CAMERA_OK);
2261 EXPECT_NE(captureSession, nullptr);
2262 Camera_OutputCapability *OutputCapability = nullptr;
2263
2264 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
2265 EXPECT_EQ(ret, CAMERA_OK);
2266
2267 OutputCapability->previewProfiles = nullptr;
2268 OutputCapability->photoProfiles = nullptr;
2269 OutputCapability->videoProfiles = nullptr;
2270 OutputCapability->supportedMetadataObjectTypes = nullptr;
2271 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2272 EXPECT_EQ(ret, 0);
2273
2274 ret = OH_Camera_DeleteCameraManager(cameraManager);
2275 EXPECT_EQ(ret, 0);
2276 }
2277
2278 /*
2279 * Feature: Framework
2280 * Function: Test cameramanager delete supported without cameraDevice and cameraOutputCapability
2281 * SubFunction: NA
2282 * FunctionPoints: NA
2283 * EnvConditions: NA
2284 * CaseDescription: Test cameramanager delete supported without cameraDevice and cameraOutputCapability
2285 */
2286 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_005, TestSize.Level0)
2287 {
2288 Camera_ErrorCode ret = CAMERA_OK;
2289 Camera_CaptureSession* captureSession = nullptr;
2290 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2291 EXPECT_EQ(ret, CAMERA_OK);
2292 EXPECT_NE(captureSession, nullptr);
2293 Camera_OutputCapability *OutputCapability = nullptr;
2294
2295 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
2296 EXPECT_EQ(ret, CAMERA_OK);
2297
2298 cameraDevice = nullptr;
2299 ret = OH_CameraManager_DeleteSupportedCameras(cameraManager, cameraDevice, cameraDeviceSize);
2300 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2301
2302 OutputCapability = nullptr;
2303 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2304 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2305
2306 ret = OH_Camera_DeleteCameraManager(cameraManager);
2307 EXPECT_EQ(ret, 0);
2308 }
2309
2310 /*
2311 * Feature: Framework
2312 * Function: Test capture session about zoom and mode with not commit
2313 * SubFunction: NA
2314 * FunctionPoints: NA
2315 * EnvConditions: NA
2316 * CaseDescription: Test capture session about zoom and mode with not commit
2317 */
2318 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_008, TestSize.Level0)
2319 {
2320 Camera_ErrorCode ret = CAMERA_OK;
2321 Camera_CaptureSession* captureSession = nullptr;
2322 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2323 EXPECT_EQ(ret, CAMERA_OK);
2324 EXPECT_NE(captureSession, nullptr);
2325
2326 float minZoom = 0.0f, maxZoom = 0.0f;
2327 ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
2328 EXPECT_EQ(ret, 0);
2329
2330 float zoom = 0.0f;
2331 ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom);
2332 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2333
2334 Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_AUTO;
2335 bool isSupportedFocusMode = true;
2336 ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode);
2337 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2338
2339 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
2340 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
2341 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2342
2343 Camera_Point FocusPointSet = {1.0, 2.0};
2344 ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet);
2345
2346 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
2347 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
2348 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2349
2350 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2351 bool isSupportedExposureMode = true;
2352 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode);
2353 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2354
2355 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2356 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
2357 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2358
2359 Camera_Point exposurePointSet = {1.0, 2.0};
2360 ret = OH_CaptureSession_SetMeteringPoint(captureSession, exposurePointSet);
2361 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2362
2363 float minExposureBias = 0.0f;
2364 ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias);
2365 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2366 }
2367
2368 /*
2369 * Feature: Framework
2370 * Function: Test capture session about zoom and mode with commit
2371 * SubFunction: NA
2372 * FunctionPoints: NA
2373 * EnvConditions: NA
2374 * CaseDescription: Test capture session about zoom and mode with commit
2375 */
2376 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_009, TestSize.Level0)
2377 {
2378 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
2379 EXPECT_NE(photoOutput, nullptr);
2380 Camera_CaptureSession* captureSession = nullptr;
2381 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2382 EXPECT_EQ(ret, CAMERA_OK);
2383 EXPECT_NE(captureSession, nullptr);
2384 Camera_Input *cameraInput = nullptr;
2385 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2386 EXPECT_EQ(ret, CAMERA_OK);
2387 EXPECT_NE(&cameraInput, nullptr);
2388
2389 ret = OH_CameraInput_Open(cameraInput);
2390 EXPECT_EQ(ret, CAMERA_OK);
2391 ret = OH_CaptureSession_BeginConfig(captureSession);
2392 EXPECT_EQ(ret, 0);
2393 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2394 EXPECT_EQ(ret, 0);
2395 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
2396 EXPECT_EQ(ret, 0);
2397
2398 ret = OH_CaptureSession_CommitConfig(captureSession);
2399 EXPECT_EQ(ret, 0);
2400
2401 ret = OH_CaptureSession_Start(captureSession);
2402 EXPECT_EQ(ret, 0);
2403
2404 float minZoom = 0.0f, maxZoom = 0.0f;
2405 ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
2406 EXPECT_EQ(ret, 0);
2407
2408 float zoom = 0.0f;
2409 ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom);
2410 EXPECT_EQ(ret, 0);
2411
2412 Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_MANUAL;
2413 bool isSupportedFocusMode = true;
2414 ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode);
2415 EXPECT_EQ(ret, 0);
2416
2417 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
2418 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
2419 EXPECT_EQ(ret, 0);
2420
2421 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
2422 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
2423 EXPECT_EQ(ret, 0);
2424
2425 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2426 bool isSupportedExposureMode = true;
2427 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode);
2428 EXPECT_EQ(ret, 0);
2429
2430 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2431 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
2432 EXPECT_EQ(ret, 0);
2433
2434 ret = OH_CaptureSession_Release(captureSession);
2435 EXPECT_EQ(ret, 0);
2436 ReleaseImageReceiver();
2437 }
2438
2439 /*
2440 * Feature: Framework
2441 * Function: Test capture session about zoom and mode with not commit
2442 * SubFunction: NA
2443 * FunctionPoints: NA
2444 * EnvConditions: NA
2445 * CaseDescription: Test capture session about zoom and mode with not commit
2446 */
2447 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_010, TestSize.Level0)
2448 {
2449 Camera_ErrorCode ret = CAMERA_OK;
2450 Camera_CaptureSession* captureSession = nullptr;
2451 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2452 EXPECT_EQ(ret, CAMERA_OK);
2453 EXPECT_NE(captureSession, nullptr);
2454
2455 float minZoom = 0.0f, maxZoom = 0.0f;
2456 ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
2457 EXPECT_EQ(ret, 0);
2458
2459 float zoom = 0.0f;
2460 ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom);
2461 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2462
2463 Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_AUTO;
2464 bool isSupportedFocusMode = true;
2465 ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode);
2466 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2467
2468 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
2469 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
2470 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2471
2472 Camera_Point FocusPointSet = {1.0, 2.0};
2473 ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet);
2474
2475 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
2476 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
2477 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2478
2479 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2480 bool isSupportedExposureMode = true;
2481 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode);
2482 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2483
2484 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2485 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
2486 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2487 }
2488
2489 /*
2490 * Feature: Framework
2491 * Function: Test capture session remove input
2492 * SubFunction: NA
2493 * FunctionPoints: NA
2494 * EnvConditions: NA
2495 * CaseDescription: Test capture session remove input
2496 */
2497 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_011, TestSize.Level0)
2498 {
2499 Camera_ErrorCode ret = CAMERA_OK;
2500 Camera_Input *cameraInput = nullptr;
2501 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2502 EXPECT_EQ(ret, CAMERA_OK);
2503 ret = OH_CameraInput_Open(cameraInput);
2504 EXPECT_EQ(ret, CAMERA_OK);
2505 Camera_CaptureSession* captureSession = nullptr;
2506 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2507 EXPECT_EQ(ret, CAMERA_OK);
2508 EXPECT_NE(captureSession, nullptr);
2509 ret = OH_CaptureSession_BeginConfig(captureSession);
2510 EXPECT_EQ(ret, 0);
2511 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2512 EXPECT_EQ(ret, 0);
2513 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2514 EXPECT_NE(previewOutput, nullptr);
2515 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2516 EXPECT_EQ(ret, 0);
2517 ret = OH_CaptureSession_CommitConfig(captureSession);
2518 EXPECT_EQ(ret, 0);
2519 ret = OH_CaptureSession_BeginConfig(captureSession);
2520 EXPECT_EQ(ret, 0);
2521 ret = OH_CaptureSession_RemoveInput(captureSession, cameraInput);
2522 EXPECT_EQ(ret, 0);
2523 ret = OH_CameraInput_Release(cameraInput);
2524 EXPECT_EQ(ret, 0);
2525 cameraInput = nullptr;
2526 }
2527
2528 /*
2529 * Feature: Framework
2530 * Function: Test preview capture photo callback
2531 * SubFunction: NA
2532 * FunctionPoints: NA
2533 * EnvConditions: NA
2534 * CaseDescription: Test preview capture photo callback
2535 */
2536 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_012, TestSize.Level0)
2537 {
2538 CameraManager_Callbacks setCameraManagerResultCallback = {
2539 .onCameraStatus = &CameraManagerOnCameraStatusCb,
2540 };
2541 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
2542 EXPECT_EQ(ret, CAMERA_OK);
2543
2544 ret = CAMERA_OK;
2545 Camera_CaptureSession* captureSession = nullptr;
2546 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2547 EXPECT_NE(captureSession, nullptr);
2548 CaptureSession_Callbacks setCaptureSessionResultCallback = {
2549 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
2550 .onError = &CameraCaptureSessionOnErrorCb
2551 };
2552 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
2553 EXPECT_EQ(ret, CAMERA_OK);
2554
2555 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2556 EXPECT_NE(previewOutput, nullptr);
2557 PreviewOutput_Callbacks setPreviewResultCallback = {
2558 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2559 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2560 .onError = &CameraPreviewOutptOnErrorCb
2561 };
2562 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2563 EXPECT_EQ(ret, CAMERA_OK);
2564
2565 Camera_Input *cameraInput = nullptr;
2566 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2567 EXPECT_EQ(ret, CAMERA_OK);
2568 CameraInput_Callbacks cameraInputCallbacks = {
2569 .onError = OnCameraInputError
2570 };
2571 ret = OH_CameraInput_RegisterCallback(cameraInput, &cameraInputCallbacks);
2572 EXPECT_EQ(ret, CAMERA_OK);
2573 ret = OH_CameraInput_Open(cameraInput);
2574 EXPECT_EQ(ret, CAMERA_OK);
2575
2576 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2577 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
2578 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), 0);
2579 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2580 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2581
2582 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), 0);
2583 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2584 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
2585 EXPECT_NE(photoOutput, nullptr);
2586 PhotoOutput_Callbacks setPhotoOutputResultCallback = {
2587 .onFrameStart = &CameraPhotoOutptOnFrameStartCb,
2588 .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb,
2589 .onFrameEnd = &CameraPhotoOutptOnFrameEndCb,
2590 .onError = &CameraPhotoOutptOnErrorCb
2591 };
2592 ret = OH_PhotoOutput_RegisterCallback(photoOutput, &setPhotoOutputResultCallback);
2593 EXPECT_EQ(ret, CAMERA_OK);
2594
2595 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), 0);
2596 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2597 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2598 EXPECT_EQ(OH_PhotoOutput_Capture(photoOutput), 0);
2599 sleep(2);
2600
2601 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), 0);
2602 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), 0);
2603 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2604 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2605 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2606 ReleaseImageReceiver();
2607 }
2608
2609 /*
2610 * Feature: Framework
2611 * Function: Test preview capture video callback
2612 * SubFunction: NA
2613 * FunctionPoints: NA
2614 * EnvConditions: NA
2615 * CaseDescription: Test preview capture video callback
2616 */
2617 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_013, TestSize.Level0)
2618 {
2619 CameraManager_Callbacks setCameraManagerResultCallback = {
2620 .onCameraStatus = &CameraManagerOnCameraStatusCb,
2621 };
2622 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
2623 EXPECT_EQ(ret, CAMERA_OK);
2624
2625 ret = CAMERA_OK;
2626 Camera_CaptureSession* captureSession = nullptr;
2627 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2628 EXPECT_NE(captureSession, nullptr);
2629 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
2630 EXPECT_EQ(ret, CAMERA_OK);
2631 CaptureSession_Callbacks setCaptureSessionResultCallback = {
2632 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
2633 .onError = &CameraCaptureSessionOnErrorCb
2634 };
2635 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
2636 EXPECT_EQ(ret, CAMERA_OK);
2637
2638 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2639 EXPECT_NE(previewOutput, nullptr);
2640 PreviewOutput_Callbacks setPreviewResultCallback = {
2641 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2642 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2643 .onError = &CameraPreviewOutptOnErrorCb
2644 };
2645 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2646 EXPECT_EQ(ret, CAMERA_OK);
2647
2648 Camera_Input *cameraInput = nullptr;
2649 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2650 EXPECT_EQ(ret, CAMERA_OK);
2651 CameraInput_Callbacks cameraInputCallbacks = {
2652 .onError = OnCameraInputError
2653 };
2654 ret = OH_CameraInput_RegisterCallback(cameraInput, &cameraInputCallbacks);
2655 EXPECT_EQ(ret, CAMERA_OK);
2656 ret = OH_CameraInput_Open(cameraInput);
2657 EXPECT_EQ(ret, CAMERA_OK);
2658
2659 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2660 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
2661 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), 0);
2662 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2663 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2664
2665 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), 0);
2666 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2667 Camera_VideoOutput* videoOutput = CreateVideoOutput();
2668 EXPECT_NE(videoOutput, nullptr);
2669 VideoOutput_Callbacks setVideoResultCallback = {
2670 .onFrameStart = &CameraVideoOutptOnFrameStartCb,
2671 .onFrameEnd = &CameraVideoOutptOnFrameEndCb,
2672 .onError = &CameraVideoOutptOnErrorCb
2673 };
2674 ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback);
2675 EXPECT_EQ(ret, CAMERA_OK);
2676
2677 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0);
2678 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2679 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2680 EXPECT_EQ(OH_VideoOutput_Start(videoOutput), 0);
2681 sleep(2);
2682
2683 EXPECT_EQ(OH_VideoOutput_Stop(videoOutput), 0);
2684 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0);
2685 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2686 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2687 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2688 ReleaseImageReceiver();
2689 }
2690
2691 /*
2692 * Feature: Framework
2693 * Function: Test Get supported scene modes and delete scene modes
2694 * SubFunction: NA
2695 * FunctionPoints: NA
2696 * EnvConditions: NA
2697 * CaseDescription: Test Get supported scene modes and delete scene modes
2698 */
2699 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_014, TestSize.Level0)
2700 {
2701 Camera_SceneMode* sceneModes = nullptr;
2702 uint32_t size = 0;
2703 Camera_ErrorCode ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
2704 EXPECT_EQ(ret, CAMERA_OK);
2705 ret = OH_CameraManager_GetSupportedSceneModes(nullptr, &sceneModes, &size);
2706 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2707 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, nullptr, &size);
2708 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2709 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, nullptr);
2710 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2711 if (sceneModes != nullptr) {
2712 ret = OH_CameraManager_DeleteSceneModes(cameraManager, sceneModes);
2713 EXPECT_EQ(ret, CAMERA_OK);
2714 }
2715 ret = OH_CameraManager_DeleteSceneModes(nullptr, sceneModes);
2716 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2717 ret = OH_CameraManager_DeleteSceneModes(cameraManager, nullptr);
2718 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2719 }
2720
2721 /*
2722 * Feature: Framework
2723 * Function: Test get supported output capabilities with scene mode
2724 * SubFunction: NA
2725 * FunctionPoints: NA
2726 * EnvConditions: NA
2727 * CaseDescription: Test get supported output capabilities with scene mode
2728 */
2729 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_015, TestSize.Level0)
2730 {
2731 Camera_CaptureSession* captureSession = nullptr;
2732 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2733 EXPECT_EQ(ret, CAMERA_OK);
2734 ASSERT_NE(captureSession, nullptr);
2735 Camera_OutputCapability *OutputCapability = nullptr;
2736 Camera_SceneMode mode = NORMAL_PHOTO;
2737 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(cameraManager, cameraDevice, mode,
2738 &OutputCapability);
2739 EXPECT_EQ(ret, CAMERA_OK);
2740 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(nullptr, cameraDevice, mode,
2741 &OutputCapability);
2742 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2743 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(cameraManager, nullptr, mode,
2744 &OutputCapability);
2745 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2746 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(cameraManager, cameraDevice, mode, nullptr);
2747 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2748 if (OutputCapability != nullptr) {
2749 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2750 EXPECT_EQ(ret, CAMERA_OK);
2751 }
2752 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(nullptr, OutputCapability);
2753 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2754 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, nullptr);
2755 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2756 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2757 }
2758
2759 /*
2760 * Feature: Framework
2761 * Function: Test if a capture session can add a camera input
2762 * SubFunction: NA
2763 * FunctionPoints: NA
2764 * EnvConditions: NA
2765 * CaseDescription: Test if a capture session can add a camera input
2766 */
2767 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_016, TestSize.Level0)
2768 {
2769 bool isSuccess = false;
2770 Camera_CaptureSession* captureSession = nullptr;
2771 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2772 EXPECT_EQ(ret, CAMERA_OK);
2773 ASSERT_NE(captureSession, nullptr);
2774 Camera_Input *cameraInput = nullptr;
2775 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2776 EXPECT_EQ(ret, CAMERA_OK);
2777 ret = OH_CameraInput_Open(cameraInput);
2778 EXPECT_EQ(ret, CAMERA_OK);
2779
2780 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
2781 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccess);
2782 EXPECT_EQ(ret, CAMERA_OK);
2783 EXPECT_EQ(isSuccess, true);
2784 ret = OH_CaptureSession_CanAddInput(nullptr, cameraInput, &isSuccess);
2785 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2786 ret = OH_CaptureSession_CanAddInput(captureSession, nullptr, &isSuccess);
2787 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2788 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, nullptr);
2789 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2790 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
2791 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2792 ASSERT_NE(previewOutput, nullptr);
2793 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2794 EXPECT_EQ(ret, CAMERA_OK);
2795 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2796
2797 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2798 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2799 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2800 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2801 }
2802
2803 /*
2804 * Feature: Framework
2805 * Function: Test if a capture session can add a preview output
2806 * SubFunction: NA
2807 * FunctionPoints: NA
2808 * EnvConditions: NA
2809 * CaseDescription: Test if a capture session can add a preview output
2810 */
2811 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_017, TestSize.Level0)
2812 {
2813 bool isSuccessful = false;
2814 Camera_CaptureSession* captureSession = nullptr;
2815 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2816 EXPECT_EQ(ret, CAMERA_OK);
2817 ASSERT_NE(captureSession, nullptr);
2818 Camera_Input *cameraInput = nullptr;
2819 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2820 EXPECT_EQ(ret, CAMERA_OK);
2821 ret = OH_CameraInput_Open(cameraInput);
2822 EXPECT_EQ(ret, CAMERA_OK);
2823
2824 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
2825 EXPECT_EQ(OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccessful), CAMERA_OK);
2826 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
2827 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2828 ASSERT_NE(previewOutput, nullptr);
2829 ret = OH_CaptureSession_CanAddPreviewOutput(captureSession, previewOutput, &isSuccessful);
2830 EXPECT_EQ(ret, CAMERA_OK);
2831 EXPECT_EQ(isSuccessful, true);
2832 ret = OH_CaptureSession_CanAddPreviewOutput(nullptr, previewOutput, &isSuccessful);
2833 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2834 ret = OH_CaptureSession_CanAddPreviewOutput(captureSession, nullptr, &isSuccessful);
2835 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2836 ret = OH_CaptureSession_CanAddPreviewOutput(captureSession, previewOutput, nullptr);
2837 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2838 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
2839 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2840
2841 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2842 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2843 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2844 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2845 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
2846 }
2847
2848 /*
2849 * Feature: Framework
2850 * Function: Test if a capture session can add a photo output
2851 * SubFunction: NA
2852 * FunctionPoints: NA
2853 * EnvConditions: NA
2854 * CaseDescription: Test if a capture session can add a photo output
2855 */
2856 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_018, TestSize.Level0)
2857 {
2858 bool isSuccessful = false;
2859 Camera_CaptureSession* captureSession = nullptr;
2860 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2861 EXPECT_EQ(ret, CAMERA_OK);
2862 ASSERT_NE(captureSession, nullptr);
2863 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
2864 EXPECT_EQ(ret, CAMERA_OK);
2865 Camera_Input *cameraInput = nullptr;
2866 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2867 EXPECT_EQ(ret, CAMERA_OK);
2868 ASSERT_NE(&cameraInput, nullptr);
2869 ret = OH_CameraInput_Open(cameraInput);
2870 EXPECT_EQ(ret, CAMERA_OK);
2871
2872 ret = OH_CaptureSession_BeginConfig(captureSession);
2873 EXPECT_EQ(ret, CAMERA_OK);
2874 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccessful);
2875 EXPECT_EQ(ret, CAMERA_OK);
2876 EXPECT_EQ(isSuccessful, true);
2877 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2878 EXPECT_EQ(ret, CAMERA_OK);
2879 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
2880 ASSERT_NE(photoOutput, nullptr);
2881 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
2882 EXPECT_EQ(ret, CAMERA_OK);
2883 EXPECT_EQ(isSuccessful, true);
2884 ret = OH_CaptureSession_CanAddPhotoOutput(nullptr, photoOutput, &isSuccessful);
2885 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2886 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, nullptr, &isSuccessful);
2887 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2888 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, nullptr);
2889 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2890 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
2891 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2892
2893 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2894 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2895 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2896 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2897 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
2898 }
2899
2900 /*
2901 * Feature: Framework
2902 * Function: Test if a capture session can add a video output
2903 * SubFunction: NA
2904 * FunctionPoints: NA
2905 * EnvConditions: NA
2906 * CaseDescription: Test if a capture session can add a video output
2907 */
2908 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_019, TestSize.Level0)
2909 {
2910 bool isSuccessful = false;
2911 Camera_CaptureSession* captureSession = nullptr;
2912 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2913 EXPECT_EQ(ret, CAMERA_OK);
2914 ASSERT_NE(captureSession, nullptr);
2915 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
2916 EXPECT_EQ(ret, CAMERA_OK);
2917 Camera_Input *cameraInput = nullptr;
2918 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2919 EXPECT_EQ(ret, CAMERA_OK);
2920 ASSERT_NE(&cameraInput, nullptr);
2921 ret = OH_CameraInput_Open(cameraInput);
2922 EXPECT_EQ(ret, CAMERA_OK);
2923
2924 ret = OH_CaptureSession_BeginConfig(captureSession);
2925 EXPECT_EQ(ret, CAMERA_OK);
2926 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccessful);
2927 EXPECT_EQ(ret, CAMERA_OK);
2928 EXPECT_EQ(isSuccessful, true);
2929 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2930 EXPECT_EQ(ret, CAMERA_OK);
2931 Camera_VideoOutput* videoOutput = CreateVideoOutput();
2932 ASSERT_NE(videoOutput, nullptr);
2933 ret = OH_CaptureSession_CanAddVideoOutput(captureSession, videoOutput, &isSuccessful);
2934 EXPECT_EQ(ret, CAMERA_OK);
2935 EXPECT_EQ(isSuccessful, true);
2936 ret = OH_CaptureSession_CanAddVideoOutput(nullptr, videoOutput, &isSuccessful);
2937 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2938 ret = OH_CaptureSession_CanAddVideoOutput(captureSession, nullptr, &isSuccessful);
2939 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2940 ret = OH_CaptureSession_CanAddVideoOutput(captureSession, videoOutput, nullptr);
2941 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2942 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), CAMERA_OK);
2943 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2944
2945 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2946 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2947 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2948 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2949 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
2950 }
2951
2952 /*
2953 * Feature: Framework
2954 * Function: Test set session mode in photo session
2955 * SubFunction: NA
2956 * FunctionPoints: NA
2957 * EnvConditions: NA
2958 * CaseDescription: Test set session mode in photo session
2959 */
2960 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_020, TestSize.Level0)
2961 {
2962 Camera_CaptureSession* captureSession = nullptr;
2963 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2964 EXPECT_EQ(ret, CAMERA_OK);
2965 ASSERT_NE(captureSession, nullptr);
2966 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
2967 EXPECT_EQ(ret, CAMERA_OK);
2968 Camera_Input *cameraInput = nullptr;
2969 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2970 EXPECT_EQ(ret, CAMERA_OK);
2971 ret = OH_CameraInput_Open(cameraInput);
2972 EXPECT_EQ(ret, CAMERA_OK);
2973
2974 ret = OH_CaptureSession_BeginConfig(captureSession);
2975 EXPECT_EQ(ret, CAMERA_OK);
2976 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2977 EXPECT_EQ(ret, CAMERA_OK);
2978 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
2979 ASSERT_NE(photoOutput, nullptr);
2980 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
2981 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2982
2983 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2984 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2985 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2986 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2987 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
2988 }
2989
2990 /*
2991 * Feature: Framework
2992 * Function: Test set session mode in video session
2993 * SubFunction: NA
2994 * FunctionPoints: NA
2995 * EnvConditions: NA
2996 * CaseDescription: Test set session mode in video session
2997 */
2998 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_021, TestSize.Level0)
2999 {
3000 Camera_CaptureSession* captureSession = nullptr;
3001 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3002 EXPECT_EQ(ret, CAMERA_OK);
3003 ASSERT_NE(captureSession, nullptr);
3004 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3005 EXPECT_EQ(ret, CAMERA_OK);
3006 Camera_Input *cameraInput = nullptr;
3007 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3008 EXPECT_EQ(ret, CAMERA_OK);
3009 ret = OH_CameraInput_Open(cameraInput);
3010 EXPECT_EQ(ret, CAMERA_OK);
3011
3012 ret = OH_CaptureSession_BeginConfig(captureSession);
3013 EXPECT_EQ(ret, CAMERA_OK);
3014 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3015 EXPECT_EQ(ret, CAMERA_OK);
3016 Camera_VideoOutput* videoOutput = CreateVideoOutput();
3017 ASSERT_NE(videoOutput, nullptr);
3018 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), CAMERA_OK);
3019 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3020
3021 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3022 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3023 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3024 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3025 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3026 }
3027
3028 /*
3029 * Feature: Framework
3030 * Function: Test set session mode in secure session
3031 * SubFunction: NA
3032 * FunctionPoints: NA
3033 * EnvConditions: NA
3034 * CaseDescription: Test set session mode in secure session
3035 */
3036 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_022, TestSize.Level0)
3037 {
3038 Camera_CaptureSession* captureSession = nullptr;
3039 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3040 EXPECT_EQ(ret, CAMERA_OK);
3041 ASSERT_NE(captureSession, nullptr);
3042 ret = OH_CaptureSession_SetSessionMode(captureSession, SECURE_PHOTO);
3043 EXPECT_EQ(ret, CAMERA_OK);
3044 Camera_SceneMode* sceneModes = nullptr;
3045 uint32_t size = 0;
3046 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
3047 EXPECT_EQ(ret, CAMERA_OK);
3048 Camera_Input *cameraInput = nullptr;
3049 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3050 EXPECT_EQ(ret, CAMERA_OK);
3051 ret = OH_CameraInput_Open(cameraInput);
3052 EXPECT_EQ(ret, CAMERA_OK);
3053
3054 ret = OH_CaptureSession_BeginConfig(captureSession);
3055 EXPECT_EQ(ret, CAMERA_OK);
3056 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3057 EXPECT_EQ(ret, CAMERA_OK);
3058 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3059 ASSERT_NE(previewOutput, nullptr);
3060 for (uint32_t i = 0; i < size; i++) {
3061 if (sceneModes[i] == SECURE_PHOTO) {
3062 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3063 EXPECT_EQ(OH_CaptureSession_AddSecureOutput(captureSession, previewOutput), CAMERA_OK);
3064 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3065 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3066 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3067 } else {
3068 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3069 ret = OH_CaptureSession_AddSecureOutput(captureSession, previewOutput);
3070 ret = OH_CaptureSession_CommitConfig(captureSession);
3071 ret = OH_CaptureSession_Start(captureSession);
3072 ret = OH_CaptureSession_Stop(captureSession);
3073 }
3074 }
3075 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3076 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3077 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3078 }
3079
3080 /*
3081 * Feature: Framework
3082 * Function: Test add a secure output to the capture session
3083 * SubFunction: NA
3084 * FunctionPoints: NA
3085 * EnvConditions: NA
3086 * CaseDescription: Test add a secure output to the capture session
3087 */
3088 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_023, TestSize.Level0)
3089 {
3090 Camera_CaptureSession* captureSession = nullptr;
3091 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3092 EXPECT_EQ(ret, CAMERA_OK);
3093 ASSERT_NE(captureSession, nullptr);
3094 ret = OH_CaptureSession_SetSessionMode(captureSession, SECURE_PHOTO);
3095 EXPECT_EQ(ret, CAMERA_OK);
3096
3097 Camera_SceneMode* sceneModes = nullptr;
3098 uint32_t size = 0;
3099 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
3100 EXPECT_EQ(ret, CAMERA_OK);
3101 Camera_Input *cameraInput = nullptr;
3102 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3103 EXPECT_EQ(ret, CAMERA_OK);
3104 ret = OH_CameraInput_Open(cameraInput);
3105 EXPECT_EQ(ret, CAMERA_OK);
3106
3107 ret = OH_CaptureSession_BeginConfig(captureSession);
3108 EXPECT_EQ(ret, CAMERA_OK);
3109 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3110 EXPECT_EQ(ret, CAMERA_OK);
3111 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3112 ASSERT_NE(previewOutput, nullptr);
3113 for (uint32_t i = 0; i < size; i++) {
3114 if (sceneModes[i] == SECURE_PHOTO) {
3115 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3116 EXPECT_EQ(OH_CaptureSession_AddSecureOutput(captureSession, previewOutput), CAMERA_OK);
3117 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3118 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3119 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3120 } else {
3121 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3122 ret = OH_CaptureSession_AddSecureOutput(captureSession, previewOutput);
3123 ret = OH_CaptureSession_CommitConfig(captureSession);
3124 ret = OH_CaptureSession_Start(captureSession);
3125 ret = OH_CaptureSession_Stop(captureSession);
3126 }
3127 }
3128 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3129 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3130 }
3131
3132 /*
3133 * Feature: Framework
3134 * Function: Test register capture session callback
3135 * SubFunction: NA
3136 * FunctionPoints: NA
3137 * EnvConditions: NA
3138 * CaseDescription: Test register capture session callback
3139 */
3140 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_024, TestSize.Level0)
3141 {
3142 Camera_CaptureSession* captureSession = nullptr;
3143 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3144 EXPECT_EQ(ret, CAMERA_OK);
3145 ASSERT_NE(captureSession, nullptr);
3146 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3147 EXPECT_EQ(ret, CAMERA_OK);
3148 Camera_Input *cameraInput = nullptr;
3149 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3150 EXPECT_EQ(ret, CAMERA_OK);
3151 CaptureSession_Callbacks setCaptureSessionResultCallback = {
3152 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
3153 .onError = &CameraCaptureSessionOnErrorCb
3154 };
3155 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
3156 EXPECT_EQ(ret, CAMERA_OK);
3157 ret = OH_CaptureSession_RegisterCallback(nullptr, &setCaptureSessionResultCallback);
3158 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3159 ret = OH_CaptureSession_RegisterCallback(captureSession, nullptr);
3160 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3161 ret = OH_CameraInput_Open(cameraInput);
3162 EXPECT_EQ(ret, CAMERA_OK);
3163
3164 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
3165 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3166
3167 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3168 ASSERT_NE(previewOutput, nullptr);
3169 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3170
3171 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
3172 ASSERT_NE(photoOutput, nullptr);
3173 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
3174 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3175
3176 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3177 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3178 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
3179 EXPECT_EQ(ret, CAMERA_OK);
3180 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3181 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3182 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3183 }
3184
3185 /*
3186 * Feature: Framework
3187 * Function: Test unregister capture session callback
3188 * SubFunction: NA
3189 * FunctionPoints: NA
3190 * EnvConditions: NA
3191 * CaseDescription: Test unregister capture session callback
3192 */
3193 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_025, TestSize.Level0)
3194 {
3195 Camera_CaptureSession* captureSession = nullptr;
3196 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3197 EXPECT_EQ(ret, CAMERA_OK);
3198 ASSERT_NE(captureSession, nullptr);
3199 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3200 EXPECT_EQ(ret, CAMERA_OK);
3201 Camera_Input *cameraInput = nullptr;
3202 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3203 EXPECT_EQ(ret, CAMERA_OK);
3204 CaptureSession_Callbacks setCaptureSessionResultCallback = {
3205 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
3206 .onError = &CameraCaptureSessionOnErrorCb
3207 };
3208 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
3209 EXPECT_EQ(ret, CAMERA_OK);
3210 ret = OH_CameraInput_Open(cameraInput);
3211 EXPECT_EQ(ret, CAMERA_OK);
3212
3213 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
3214 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3215
3216 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3217 ASSERT_NE(previewOutput, nullptr);
3218 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3219
3220 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
3221 ASSERT_NE(photoOutput, nullptr);
3222 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
3223
3224 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3225 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3226 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3227 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
3228 EXPECT_EQ(ret, CAMERA_OK);
3229 ret = OH_CaptureSession_UnregisterCallback(nullptr, &setCaptureSessionResultCallback);
3230 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3231 ret = OH_CaptureSession_UnregisterCallback(captureSession, nullptr);
3232 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3233 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3234 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3235 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3236 }
3237
3238 /*
3239 * Feature: Framework
3240 * Function: Test open secure camera
3241 * SubFunction: NA
3242 * FunctionPoints: NA
3243 * EnvConditions: NA
3244 * CaseDescription: Test open secure camera
3245 */
3246 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_026, TestSize.Level0)
3247 {
3248 uint64_t secureSeqId = 10;
3249 Camera_CaptureSession* captureSession = nullptr;
3250 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3251 EXPECT_EQ(ret, CAMERA_OK);
3252 ASSERT_NE(captureSession, nullptr);
3253 ret = OH_CaptureSession_SetSessionMode(captureSession, SECURE_PHOTO);
3254 EXPECT_EQ(ret, CAMERA_OK);
3255
3256 Camera_SceneMode* sceneModes = nullptr;
3257 uint32_t size = 0;
3258 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
3259 EXPECT_EQ(ret, CAMERA_OK);
3260 Camera_Input *cameraInput = nullptr;
3261 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3262 EXPECT_EQ(ret, CAMERA_OK);
3263 ret = OH_CameraInput_Open(cameraInput);
3264 EXPECT_EQ(ret, CAMERA_OK);
3265
3266 ret = OH_CaptureSession_BeginConfig(captureSession);
3267 EXPECT_EQ(ret, CAMERA_OK);
3268 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3269 EXPECT_EQ(ret, CAMERA_OK);
3270 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3271 ASSERT_NE(previewOutput, nullptr);
3272 for (uint32_t i = 0; i < size; i++) {
3273 if (sceneModes[i] == SECURE_PHOTO) {
3274 ret = OH_CameraInput_OpenSecureCamera(cameraInput, &secureSeqId);
3275 EXPECT_EQ(ret, CAMERA_OK);
3276 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3277 EXPECT_EQ(OH_CaptureSession_AddSecureOutput(captureSession, previewOutput), CAMERA_OK);
3278 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3279 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3280 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3281 } else {
3282 ret = OH_CameraInput_OpenSecureCamera(cameraInput, &secureSeqId);
3283 ret = OH_CameraInput_OpenSecureCamera(nullptr, &secureSeqId);
3284 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3285 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3286 ret = OH_CaptureSession_AddSecureOutput(captureSession, previewOutput);
3287 ret = OH_CaptureSession_CommitConfig(captureSession);
3288 ret = OH_CaptureSession_Start(captureSession);
3289 ret = OH_CaptureSession_Stop(captureSession);
3290 }
3291 }
3292 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3293 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3294 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3295 }
3296
3297
3298 /*
3299 * Feature: Framework
3300 * Function: Test create preview output used in preconfig
3301 * SubFunction: NA
3302 * FunctionPoints: NA
3303 * EnvConditions: NA
3304 * CaseDescription: Test create preview output used in preconfig
3305 */
3306 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_027, TestSize.Level0)
3307 {
3308 sptr<IConsumerSurface> previewSurface = IConsumerSurface::Create();
3309 sptr<IBufferProducer> previewProducer = previewSurface->GetProducer();
3310 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(previewProducer);
3311 int64_t surfaceIdInt = previewProducer->GetUniqueId();
3312 string surfaceIdStr = std::to_string(surfaceIdInt);
3313 const char *surfaceId = nullptr;
3314 surfaceId = surfaceIdStr.c_str();
3315 SurfaceUtils::GetInstance()->Add(surfaceIdInt, pSurface);
3316 ASSERT_NE(surfaceId, nullptr);
3317
3318 Camera_CaptureSession* captureSession = nullptr;
3319 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3320 EXPECT_EQ(ret, CAMERA_OK);
3321 ASSERT_NE(captureSession, nullptr);
3322 bool canPreconfig = false;
3323 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3324 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3325 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3326 EXPECT_EQ(ret, CAMERA_OK);
3327 if (canPreconfig == true) {
3328 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3329 EXPECT_EQ(ret, CAMERA_OK);
3330 Camera_Input *cameraInput = nullptr;
3331 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3332 EXPECT_EQ(ret, CAMERA_OK);
3333 ASSERT_NE(&cameraInput, nullptr);
3334 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3335 ret = OH_CaptureSession_BeginConfig(captureSession);
3336 EXPECT_EQ(ret, CAMERA_OK);
3337 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
3338 Camera_PreviewOutput* previewOutput = nullptr;
3339 ret = OH_CameraManager_CreatePreviewOutputUsedInPreconfig(cameraManager, surfaceId, &previewOutput);
3340 EXPECT_EQ(ret, CAMERA_OK);
3341 ASSERT_NE(previewOutput, nullptr);
3342 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3343 EXPECT_EQ(ret, CAMERA_OK);
3344 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3345 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), CAMERA_OK);
3346 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), CAMERA_OK);
3347 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3348 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3349 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3350 }
3351 }
3352
3353 /*
3354 * Feature: Framework
3355 * Function: Test create photo output used in preconfig
3356 * SubFunction: NA
3357 * FunctionPoints: NA
3358 * EnvConditions: NA
3359 * CaseDescription: Test create photo output used in preconfig
3360 */
3361 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_028, TestSize.Level0)
3362 {
3363 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3364 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3365 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3366 const char* surfaceId = nullptr;
3367 surfaceId = receiverKey.c_str();
3368 ASSERT_NE(surfaceId, nullptr);
3369
3370 Camera_CaptureSession* captureSession = nullptr;
3371 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3372 EXPECT_EQ(ret, CAMERA_OK);
3373 ASSERT_NE(captureSession, nullptr);
3374 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3375 EXPECT_EQ(ret, CAMERA_OK);
3376 bool canPreconfig = false;
3377 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3378 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3379 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3380 EXPECT_EQ(ret, CAMERA_OK);
3381 if (canPreconfig == true) {
3382 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3383 EXPECT_EQ(ret, CAMERA_OK);
3384 Camera_Input *cameraInput = nullptr;
3385 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3386 EXPECT_EQ(ret, CAMERA_OK);
3387 ASSERT_NE(&cameraInput, nullptr);
3388 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3389 ret = OH_CaptureSession_BeginConfig(captureSession);
3390 EXPECT_EQ(ret, CAMERA_OK);
3391 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3392 Camera_PhotoOutput *photoOutput = nullptr;
3393 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3394 EXPECT_EQ(ret, CAMERA_OK);
3395 ASSERT_NE(photoOutput, nullptr);
3396 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3397 EXPECT_EQ(ret, CAMERA_OK);
3398 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3399 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3400 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3401 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3402 }
3403 }
3404
3405 /*
3406 * Feature: Framework
3407 * Function: Test create video output used in preconfig
3408 * SubFunction: NA
3409 * FunctionPoints: NA
3410 * EnvConditions: NA
3411 * CaseDescription: Test create video output used in preconfig
3412 */
3413 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_029, TestSize.Level0)
3414 {
3415 sptr<IConsumerSurface> videoSurface = IConsumerSurface::Create();
3416 sptr<IBufferProducer> videoProducer = videoSurface->GetProducer();
3417 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(videoProducer);
3418 int64_t surfaceIdInt = videoProducer->GetUniqueId();
3419 string surfaceIdStr = std::to_string(surfaceIdInt);
3420 const char *surfaceId = nullptr;
3421 surfaceId = surfaceIdStr.c_str();
3422 SurfaceUtils::GetInstance()->Add(surfaceIdInt, pSurface);
3423 ASSERT_NE(surfaceId, nullptr);
3424
3425 Camera_CaptureSession* captureSession = nullptr;
3426 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3427 EXPECT_EQ(ret, CAMERA_OK);
3428 ASSERT_NE(captureSession, nullptr);
3429 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3430 EXPECT_EQ(ret, CAMERA_OK);
3431
3432 bool canPreconfig = false;
3433 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3434 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3435 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3436 EXPECT_EQ(ret, CAMERA_OK);
3437 if (canPreconfig == true) {
3438 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3439 EXPECT_EQ(ret, CAMERA_OK);
3440 Camera_Input *cameraInput = nullptr;
3441 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3442 EXPECT_EQ(ret, CAMERA_OK);
3443 ASSERT_NE(&cameraInput, nullptr);
3444 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3445 ret = OH_CaptureSession_BeginConfig(captureSession);
3446 EXPECT_EQ(ret, CAMERA_OK);
3447 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3448 Camera_VideoOutput *videoOutput = nullptr;
3449 ret = OH_CameraManager_CreateVideoOutputUsedInPreconfig(cameraManager, surfaceId, &videoOutput);
3450 EXPECT_EQ(ret, CAMERA_OK);
3451 ASSERT_NE(videoOutput, nullptr);
3452 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
3453 EXPECT_EQ(ret, CAMERA_OK);
3454 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3455 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3456 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3457 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3458 }
3459 }
3460
3461 /*
3462 * Feature: Framework
3463 * Function: Test can preconfig or not
3464 * SubFunction: NA
3465 * FunctionPoints: NA
3466 * EnvConditions: NA
3467 * CaseDescription: Test can preconfig or not
3468 */
3469 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_030, TestSize.Level0)
3470 {
3471 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3472 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3473 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3474 const char* surfaceId = nullptr;
3475 surfaceId = receiverKey.c_str();
3476 ASSERT_NE(surfaceId, nullptr);
3477
3478 Camera_CaptureSession* captureSession = nullptr;
3479 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3480 EXPECT_EQ(ret, CAMERA_OK);
3481 ASSERT_NE(captureSession, nullptr);
3482 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3483 EXPECT_EQ(ret, CAMERA_OK);
3484
3485 bool canPreconfig = false;
3486 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3487 ret = OH_CaptureSession_CanPreconfig(nullptr, preconfigType, &canPreconfig);
3488 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3489 ret = OH_CaptureSession_CanPreconfig(captureSession, preconfigType, nullptr);
3490 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3491 ret = OH_CaptureSession_CanPreconfig(captureSession, preconfigType, &canPreconfig);
3492 EXPECT_EQ(ret, CAMERA_OK);
3493 if (canPreconfig == true) {
3494 ret = OH_CaptureSession_Preconfig(captureSession, preconfigType);
3495 EXPECT_EQ(ret, CAMERA_OK);
3496 Camera_Input *cameraInput = nullptr;
3497 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3498 EXPECT_EQ(ret, CAMERA_OK);
3499 ASSERT_NE(&cameraInput, nullptr);
3500 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3501 ret = OH_CaptureSession_BeginConfig(captureSession);
3502 EXPECT_EQ(ret, CAMERA_OK);
3503 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3504 Camera_PhotoOutput *photoOutput = nullptr;
3505 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3506 EXPECT_EQ(ret, CAMERA_OK);
3507 ASSERT_NE(photoOutput, nullptr);
3508 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3509 EXPECT_EQ(ret, CAMERA_OK);
3510 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3511 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3512 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3513 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3514 }
3515 }
3516
3517 /*
3518 * Feature: Framework
3519 * Function: Test can preconfig or not with ratio
3520 * SubFunction: NA
3521 * FunctionPoints: NA
3522 * EnvConditions: NA
3523 * CaseDescription: Test can preconfig or not with ratio
3524 */
3525 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_031, TestSize.Level0)
3526 {
3527 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3528 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3529 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3530 const char* surfaceId = nullptr;
3531 surfaceId = receiverKey.c_str();
3532 ASSERT_NE(surfaceId, nullptr);
3533
3534 Camera_CaptureSession* captureSession = nullptr;
3535 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3536 EXPECT_EQ(ret, CAMERA_OK);
3537 ASSERT_NE(captureSession, nullptr);
3538 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3539 EXPECT_EQ(ret, CAMERA_OK);
3540
3541 bool canPreconfig = false;
3542 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3543 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3544 ret = OH_CaptureSession_CanPreconfigWithRatio(nullptr, preconfigType, preconfigRatio, &canPreconfig);
3545 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3546 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, nullptr);
3547 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3548 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3549 EXPECT_EQ(ret, CAMERA_OK);
3550 if (canPreconfig == true) {
3551 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3552 EXPECT_EQ(ret, CAMERA_OK);
3553 Camera_Input *cameraInput = nullptr;
3554 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3555 EXPECT_EQ(ret, CAMERA_OK);
3556 ASSERT_NE(&cameraInput, nullptr);
3557 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3558 ret = OH_CaptureSession_BeginConfig(captureSession);
3559 EXPECT_EQ(ret, CAMERA_OK);
3560 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3561 Camera_PhotoOutput *photoOutput = nullptr;
3562 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3563 EXPECT_EQ(ret, CAMERA_OK);
3564 ASSERT_NE(photoOutput, nullptr);
3565 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3566 EXPECT_EQ(ret, CAMERA_OK);
3567 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3568 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3569 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3570 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3571 }
3572 }
3573
3574 /*
3575 * Feature: Framework
3576 * Function: Test preconfig
3577 * SubFunction: NA
3578 * FunctionPoints: NA
3579 * EnvConditions: NA
3580 * CaseDescription: Test preconfig
3581 */
3582 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_032, TestSize.Level0)
3583 {
3584 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3585 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3586 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3587 const char* surfaceId = nullptr;
3588 surfaceId = receiverKey.c_str();
3589 ASSERT_NE(surfaceId, nullptr);
3590
3591 Camera_CaptureSession* captureSession = nullptr;
3592 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3593 EXPECT_EQ(ret, CAMERA_OK);
3594 ASSERT_NE(captureSession, nullptr);
3595 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3596 EXPECT_EQ(ret, CAMERA_OK);
3597
3598 bool canPreconfig = false;
3599 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3600 ret = OH_CaptureSession_CanPreconfig(captureSession, preconfigType, &canPreconfig);
3601 EXPECT_EQ(ret, CAMERA_OK);
3602 if (canPreconfig == true) {
3603 ret = OH_CaptureSession_Preconfig(captureSession, preconfigType);
3604 EXPECT_EQ(ret, CAMERA_OK);
3605 Camera_Input *cameraInput = nullptr;
3606 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3607 EXPECT_EQ(ret, CAMERA_OK);
3608 ASSERT_NE(&cameraInput, nullptr);
3609 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3610 ret = OH_CaptureSession_BeginConfig(captureSession);
3611 EXPECT_EQ(ret, CAMERA_OK);
3612 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3613 Camera_PhotoOutput *photoOutput = nullptr;
3614 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3615 EXPECT_EQ(ret, CAMERA_OK);
3616 ASSERT_NE(photoOutput, nullptr);
3617 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3618 EXPECT_EQ(ret, CAMERA_OK);
3619 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3620 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3621 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3622 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3623 } else {
3624 ret = OH_CaptureSession_Preconfig(nullptr, preconfigType);
3625 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3626 }
3627 }
3628
3629 /*
3630 * Feature: Framework
3631 * Function: Test preconfig with ratio
3632 * SubFunction: NA
3633 * FunctionPoints: NA
3634 * EnvConditions: NA
3635 * CaseDescription: Test preconfig with ratio
3636 */
3637 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_033, TestSize.Level0)
3638 {
3639 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3640 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3641 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3642 const char* surfaceId = nullptr;
3643 surfaceId = receiverKey.c_str();
3644 ASSERT_NE(surfaceId, nullptr);
3645
3646 Camera_CaptureSession* captureSession = nullptr;
3647 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3648 EXPECT_EQ(ret, CAMERA_OK);
3649 ASSERT_NE(captureSession, nullptr);
3650 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3651 EXPECT_EQ(ret, CAMERA_OK);
3652
3653 bool canPreconfig = false;
3654 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3655 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3656 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3657 EXPECT_EQ(ret, CAMERA_OK);
3658 if (canPreconfig == true) {
3659 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3660 EXPECT_EQ(ret, CAMERA_OK);
3661 Camera_Input *cameraInput = nullptr;
3662 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3663 EXPECT_EQ(ret, CAMERA_OK);
3664 ASSERT_NE(&cameraInput, nullptr);
3665 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3666 ret = OH_CaptureSession_BeginConfig(captureSession);
3667 EXPECT_EQ(ret, CAMERA_OK);
3668 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3669 Camera_PhotoOutput *photoOutput = nullptr;
3670 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3671 EXPECT_EQ(ret, CAMERA_OK);
3672 ASSERT_NE(photoOutput, nullptr);
3673 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3674 EXPECT_EQ(ret, CAMERA_OK);
3675 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3676 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3677 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3678 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3679 } else {
3680 ret = OH_CaptureSession_PreconfigWithRatio(nullptr, preconfigType, preconfigRatio);
3681 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3682 }
3683 }
3684
3685 /*
3686 * Feature: Framework
3687 * Function: Test get active profile of priview output and delete profile of priview output
3688 * SubFunction: NA
3689 * FunctionPoints: NA
3690 * EnvConditions: NA
3691 * CaseDescription: Test get active profile of priview output and delete profile of priview output
3692 */
3693 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_034, TestSize.Level0)
3694 {
3695 Camera_Profile *profile = nullptr;
3696 Camera_CaptureSession* captureSession = nullptr;
3697 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3698 EXPECT_EQ(ret, CAMERA_OK);
3699 ASSERT_NE(captureSession, nullptr);
3700 Camera_Input *cameraInput = nullptr;
3701 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3702 EXPECT_EQ(ret, CAMERA_OK);
3703 ASSERT_NE(&cameraInput, nullptr);
3704 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3705
3706 ret = OH_CaptureSession_BeginConfig(captureSession);
3707 EXPECT_EQ(ret, CAMERA_OK);
3708 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3709 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3710 ASSERT_NE(previewOutput, nullptr);
3711 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3712 EXPECT_EQ(ret, CAMERA_OK);
3713 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3714
3715 ret = OH_PreviewOutput_GetActiveProfile(previewOutput, &profile);
3716 EXPECT_EQ(ret, CAMERA_OK);
3717 ret = OH_PreviewOutput_GetActiveProfile(nullptr, &profile);
3718 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3719 ret = OH_PreviewOutput_GetActiveProfile(previewOutput, nullptr);
3720 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3721 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), CAMERA_OK);
3722 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), CAMERA_OK);
3723 if (profile != nullptr) {
3724 EXPECT_EQ(OH_PreviewOutput_DeleteProfile(profile), CAMERA_OK);
3725 }
3726 EXPECT_EQ(OH_PreviewOutput_DeleteProfile(nullptr), CAMERA_INVALID_ARGUMENT);
3727 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3728 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3729 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3730 }
3731
3732 /*
3733 * Feature: Framework
3734 * Function: Test get active profile of photo output and delete profile of photo output
3735 * SubFunction: NA
3736 * FunctionPoints: NA
3737 * EnvConditions: NA
3738 * CaseDescription: Test get active profile of photo output and delete profile of photo output
3739 */
3740 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_035, TestSize.Level0)
3741 {
3742 Camera_Profile* profile = nullptr;
3743 Camera_CaptureSession* captureSession = nullptr;
3744 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3745 EXPECT_EQ(ret, CAMERA_OK);
3746 ASSERT_NE(captureSession, nullptr);
3747 Camera_Input *cameraInput = nullptr;
3748 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3749 EXPECT_EQ(ret, CAMERA_OK);
3750 ASSERT_NE(&cameraInput, nullptr);
3751 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3752
3753 ret = OH_CaptureSession_BeginConfig(captureSession);
3754 EXPECT_EQ(ret, CAMERA_OK);
3755 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3756 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
3757 ASSERT_NE(photooutput, nullptr);
3758 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
3759 EXPECT_EQ(ret, CAMERA_OK);
3760 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3761
3762 ret = OH_PhotoOutput_GetActiveProfile(photooutput, &profile);
3763 EXPECT_EQ(ret, CAMERA_OK);
3764 ret = OH_PhotoOutput_GetActiveProfile(nullptr, &profile);
3765 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3766 ret = OH_PhotoOutput_GetActiveProfile(photooutput, nullptr);
3767 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3768 if (profile != nullptr) {
3769 EXPECT_EQ(OH_PhotoOutput_DeleteProfile(profile), CAMERA_OK);
3770 }
3771 EXPECT_EQ(OH_PhotoOutput_DeleteProfile(nullptr), CAMERA_INVALID_ARGUMENT);
3772 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
3773 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3774 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3775 }
3776
3777 /*
3778 * Feature: Framework
3779 * Function: Test get active profile of video output and delete profile of video output
3780 * SubFunction: NA
3781 * FunctionPoints: NA
3782 * EnvConditions: NA
3783 * CaseDescription: Test get active profile of video output and delete profile of video output
3784 */
3785 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_036, TestSize.Level0)
3786 {
3787 Camera_VideoProfile* videoProfile = nullptr;
3788 Camera_CaptureSession* captureSession = nullptr;
3789 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3790 EXPECT_EQ(ret, CAMERA_OK);
3791 ASSERT_NE(captureSession, nullptr);
3792 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3793 EXPECT_EQ(ret, CAMERA_OK);
3794 Camera_Input *cameraInput = nullptr;
3795 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3796 EXPECT_EQ(ret, CAMERA_OK);
3797 ASSERT_NE(&cameraInput, nullptr);
3798 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3799
3800 ret = OH_CaptureSession_BeginConfig(captureSession);
3801 EXPECT_EQ(ret, 0);
3802 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
3803 Camera_VideoOutput* videoOutput = CreateVideoOutput();
3804 ASSERT_NE(videoOutput, nullptr);
3805 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
3806 EXPECT_EQ(ret, CAMERA_OK);
3807 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3808
3809 ret = OH_VideoOutput_GetActiveProfile(videoOutput, &videoProfile);
3810 EXPECT_EQ(ret, CAMERA_OK);
3811 ret = OH_VideoOutput_GetActiveProfile(nullptr, &videoProfile);
3812 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3813 ret = OH_VideoOutput_GetActiveProfile(videoOutput, nullptr);
3814 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3815 if (videoProfile != nullptr) {
3816 EXPECT_EQ(OH_VideoOutput_DeleteProfile(videoProfile), CAMERA_OK);
3817 }
3818 EXPECT_EQ(OH_VideoOutput_DeleteProfile(nullptr), CAMERA_INVALID_ARGUMENT);
3819 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3820 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3821 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3822 }
3823
3824 /*
3825 * Feature: Framework
3826 * Function: Test camera orientation
3827 * SubFunction: NA
3828 * FunctionPoints: NA
3829 * EnvConditions: NA
3830 * CaseDescription: Test camera orientation
3831 */
3832 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_037, TestSize.Level0)
3833 {
3834 Camera_Input *cameraInput = nullptr;
3835 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3836 EXPECT_EQ(ret, CAMERA_OK);
3837 EXPECT_NE(&cameraInput, nullptr);
3838 ret = OH_CameraInput_Open(cameraInput);
3839 EXPECT_EQ(ret, CAMERA_OK);
3840
3841 uint32_t orientation = 0;
3842 ret = OH_CameraDevice_GetCameraOrientation(cameraDevice, &orientation);
3843 EXPECT_EQ(ret, 0);
3844 ret = OH_CameraInput_Release(cameraInput);
3845 EXPECT_EQ(ret, 0);
3846 }
3847
3848 /*
3849 * Feature: Framework
3850 * Function: Test Torch supported or not and supported or not with torch mode
3851 * SubFunction: NA
3852 * FunctionPoints: NA
3853 * EnvConditions: NA
3854 * CaseDescription: Test is Torch supported or not and supported or not with torch mode
3855 */
3856 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_038, TestSize.Level0)
3857 {
3858 Camera_CaptureSession* captureSession = nullptr;
3859 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3860 EXPECT_EQ(ret, CAMERA_OK);
3861 ASSERT_NE(captureSession, nullptr);
3862 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3863 EXPECT_EQ(ret, CAMERA_OK);
3864 ret = OH_CaptureSession_BeginConfig(captureSession);
3865 EXPECT_EQ(ret, CAMERA_OK);
3866 Camera_Input *cameraInput = nullptr;
3867 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3868 EXPECT_EQ(ret, CAMERA_OK);
3869 ASSERT_NE(&cameraInput, nullptr);
3870 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3871 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3872 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
3873 ASSERT_NE(photooutput, nullptr);
3874 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
3875 EXPECT_EQ(ret, CAMERA_OK);
3876 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3877 bool isTorchSupported = false;
3878 Camera_TorchMode torchMode = ON;
3879 ret = OH_CameraManager_IsTorchSupported(cameraManager, &isTorchSupported);
3880 EXPECT_EQ(ret, CAMERA_OK);
3881 if (isTorchSupported == true) {
3882 ret = OH_CameraManager_IsTorchSupportedByTorchMode(cameraManager, torchMode, &isTorchSupported);
3883 EXPECT_EQ(ret, CAMERA_OK);
3884 if (isTorchSupported == true) {
3885 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
3886 if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_FRONT) {
3887 EXPECT_EQ(ret, CAMERA_OK);
3888 } else if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_BACK) {
3889 EXPECT_EQ(ret, Camera_ErrorCode::CAMERA_OPERATION_NOT_ALLOWED);
3890 }
3891 } else {
3892 ret = OH_CameraManager_IsTorchSupportedByTorchMode(nullptr, torchMode, &isTorchSupported);
3893 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3894 ret = OH_CameraManager_IsTorchSupportedByTorchMode(cameraManager, torchMode, nullptr);
3895 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3896 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
3897 }
3898 } else {
3899 ret = OH_CameraManager_IsTorchSupported(nullptr, &isTorchSupported);
3900 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3901 ret = OH_CameraManager_IsTorchSupported(cameraManager, nullptr);
3902 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3903 }
3904 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
3905 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3906 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3907 }
3908
3909 /*
3910 * Feature: Framework
3911 * Function: Test set torch mode
3912 * SubFunction: NA
3913 * FunctionPoints: NA
3914 * EnvConditions: NA
3915 * CaseDescription: Test set torch mode
3916 */
3917 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_039, TestSize.Level0)
3918 {
3919 Camera_CaptureSession* captureSession = nullptr;
3920 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3921 EXPECT_EQ(ret, CAMERA_OK);
3922 ASSERT_NE(captureSession, nullptr);
3923 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3924 EXPECT_EQ(ret, CAMERA_OK);
3925 ret = OH_CaptureSession_BeginConfig(captureSession);
3926 EXPECT_EQ(ret, CAMERA_OK);
3927 Camera_Input *cameraInput = nullptr;
3928 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3929 EXPECT_EQ(ret, CAMERA_OK);
3930 ASSERT_NE(&cameraInput, nullptr);
3931 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3932 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3933 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
3934 ASSERT_NE(photooutput, nullptr);
3935 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
3936 EXPECT_EQ(ret, CAMERA_OK);
3937 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3938 bool isTorchSupported = false;
3939 Camera_TorchMode torchMode = ON;
3940 ret = OH_CameraManager_IsTorchSupported(cameraManager, &isTorchSupported);
3941 EXPECT_EQ(ret, CAMERA_OK);
3942 if (isTorchSupported == true) {
3943 ret = OH_CameraManager_IsTorchSupportedByTorchMode(cameraManager, torchMode, &isTorchSupported);
3944 EXPECT_EQ(ret, CAMERA_OK);
3945 if (isTorchSupported == true) {
3946 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
3947 if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_FRONT) {
3948 EXPECT_EQ(ret, CAMERA_OK);
3949 } else if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_BACK) {
3950 EXPECT_EQ(ret, Camera_ErrorCode::CAMERA_OPERATION_NOT_ALLOWED);
3951 }
3952 } else {
3953 ret = OH_CameraManager_SetTorchMode(nullptr, torchMode);
3954 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3955 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
3956 }
3957 }
3958 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
3959 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3960 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3961 }
3962
3963 /*
3964 * Feature: Framework
3965 * Function: Test register camera manager callback
3966 * SubFunction: NA
3967 * FunctionPoints: NA
3968 * EnvConditions: NA
3969 * CaseDescription: Test register camera manager callback
3970 */
3971 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_040, TestSize.Level0)
3972 {
3973 CameraManager_Callbacks setCameraManagerResultCallback = {
3974 .onCameraStatus = &CameraManagerOnCameraStatusCb
3975 };
3976 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
3977 EXPECT_EQ(ret, CAMERA_OK);
3978 ret = OH_CameraManager_RegisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
3979 EXPECT_EQ(ret, CAMERA_OK);
3980 ret = OH_CameraManager_RegisterTorchStatusCallback(nullptr, CameraManagerOnCameraTorchStatusCb);
3981 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3982 ret = OH_CameraManager_RegisterTorchStatusCallback(cameraManager, nullptr);
3983 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3984 ret = OH_CameraManager_UnregisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
3985 EXPECT_EQ(ret, CAMERA_OK);
3986 }
3987
3988 /*
3989 * Feature: Framework
3990 * Function: Test unregister camera manager callback
3991 * SubFunction: NA
3992 * FunctionPoints: NA
3993 * EnvConditions: NA
3994 * CaseDescription: Test unregister camera manager callback
3995 */
3996 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_041, TestSize.Level0)
3997 {
3998 CameraManager_Callbacks setCameraManagerResultCallback = {
3999 .onCameraStatus = &CameraManagerOnCameraStatusCb
4000 };
4001 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
4002 EXPECT_EQ(ret, CAMERA_OK);
4003 ret = OH_CameraManager_RegisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
4004 EXPECT_EQ(ret, CAMERA_OK);
4005 ret = OH_CameraManager_UnregisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
4006 EXPECT_EQ(ret, CAMERA_OK);
4007 ret = OH_CameraManager_UnregisterTorchStatusCallback(nullptr, CameraManagerOnCameraTorchStatusCb);
4008 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4009 ret = OH_CameraManager_UnregisterTorchStatusCallback(cameraManager, nullptr);
4010 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4011 }
4012
4013 /*
4014 * Feature: Framework
4015 * Function: Test get exposure value
4016 * SubFunction: NA
4017 * FunctionPoints: NA
4018 * EnvConditions: NA
4019 * CaseDescription: Test get exposure value
4020 */
4021 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_042, TestSize.Level0)
4022 {
4023 float exposureValue = 0.0f;
4024 Camera_CaptureSession* captureSession = nullptr;
4025 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4026 EXPECT_EQ(ret, CAMERA_OK);
4027 ASSERT_NE(captureSession, nullptr);
4028 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4029 EXPECT_EQ(ret, CAMERA_OK);
4030 ret = OH_CaptureSession_BeginConfig(captureSession);
4031 EXPECT_EQ(ret, CAMERA_OK);
4032 Camera_Input *cameraInput = nullptr;
4033 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4034 EXPECT_EQ(ret, CAMERA_OK);
4035 ASSERT_NE(&cameraInput, nullptr);
4036 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4037 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4038 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4039 ASSERT_NE(photooutput, nullptr);
4040 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4041 EXPECT_EQ(ret, CAMERA_OK);
4042 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4043 ret = OH_CaptureSession_GetExposureValue(captureSession, &exposureValue);
4044 EXPECT_EQ(ret, CAMERA_OK);
4045 ret = OH_CaptureSession_GetExposureValue(nullptr, &exposureValue);
4046 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4047 ret = OH_CaptureSession_GetExposureValue(captureSession, nullptr);
4048 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4049 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4050 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4051 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4052 }
4053
4054 /*
4055 * Feature: Framework
4056 * Function: Test get focal length
4057 * SubFunction: NA
4058 * FunctionPoints: NA
4059 * EnvConditions: NA
4060 * CaseDescription: Test get focal length
4061 */
4062 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_043, TestSize.Level0)
4063 {
4064 float focalLength = 0.0f;
4065 Camera_CaptureSession* captureSession = nullptr;
4066 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4067 EXPECT_EQ(ret, CAMERA_OK);
4068 ASSERT_NE(captureSession, nullptr);
4069 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4070 EXPECT_EQ(ret, CAMERA_OK);
4071 ret = OH_CaptureSession_BeginConfig(captureSession);
4072 EXPECT_EQ(ret, CAMERA_OK);
4073 Camera_Input *cameraInput = nullptr;
4074 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4075 EXPECT_EQ(ret, CAMERA_OK);
4076 ASSERT_NE(&cameraInput, nullptr);
4077 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4078 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4079 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4080 ASSERT_NE(photooutput, nullptr);
4081 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4082 EXPECT_EQ(ret, CAMERA_OK);
4083 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4084 ret = OH_CaptureSession_GetFocalLength(captureSession, &focalLength);
4085 EXPECT_EQ(ret, CAMERA_OK);
4086 ret = OH_CaptureSession_GetFocalLength(nullptr, &focalLength);
4087 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4088 ret = OH_CaptureSession_GetFocalLength(captureSession, nullptr);
4089 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4090 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4091 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4092 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4093 }
4094
4095 /*
4096 * Feature: Framework
4097 * Function: Test set smooth zoom
4098 * SubFunction: NA
4099 * FunctionPoints: NA
4100 * EnvConditions: NA
4101 * CaseDescription: Test set smooth zoom
4102 */
4103 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_044, TestSize.Level0)
4104 {
4105 float targetZoom = 0.0f;
4106 Camera_SmoothZoomMode smoothZoomMode = Camera_SmoothZoomMode::NORMAL;
4107 Camera_CaptureSession* captureSession = nullptr;
4108 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4109 EXPECT_EQ(ret, CAMERA_OK);
4110 ASSERT_NE(captureSession, nullptr);
4111 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4112 EXPECT_EQ(ret, CAMERA_OK);
4113 ret = OH_CaptureSession_BeginConfig(captureSession);
4114 EXPECT_EQ(ret, CAMERA_OK);
4115 Camera_Input *cameraInput = nullptr;
4116 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4117 EXPECT_EQ(ret, CAMERA_OK);
4118 ASSERT_NE(&cameraInput, nullptr);
4119 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4120 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4121 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4122 ASSERT_NE(photooutput, nullptr);
4123 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4124 EXPECT_EQ(ret, CAMERA_OK);
4125 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4126 ret = OH_CaptureSession_SetSmoothZoom(captureSession, targetZoom, smoothZoomMode);
4127 EXPECT_EQ(ret, CAMERA_OK);
4128 ret = OH_CaptureSession_SetSmoothZoom(nullptr, targetZoom, smoothZoomMode);
4129 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4130 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4131 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4132 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4133 }
4134
4135 /*
4136 * Feature: Framework
4137 * Function: Test get supported color space
4138 * SubFunction: NA
4139 * FunctionPoints: NA
4140 * EnvConditions: NA
4141 * CaseDescription: Test get supported color space
4142 */
4143 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_045, TestSize.Level0)
4144 {
4145 uint32_t size = 0;
4146 OH_NativeBuffer_ColorSpace* colorSpace = nullptr;
4147 Camera_CaptureSession* captureSession = nullptr;
4148 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4149 EXPECT_EQ(ret, CAMERA_OK);
4150 ASSERT_NE(captureSession, nullptr);
4151 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4152 EXPECT_EQ(ret, CAMERA_OK);
4153 ret = OH_CaptureSession_GetSupportedColorSpaces(nullptr, &colorSpace, &size);
4154 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4155 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, nullptr, &size);
4156 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4157 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, nullptr);
4158 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4159 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, &size);
4160 EXPECT_EQ(ret, CAMERA_OK);
4161 Camera_Input *cameraInput = nullptr;
4162 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4163 EXPECT_EQ(ret, CAMERA_OK);
4164 ret = OH_CameraInput_Open(cameraInput);
4165 EXPECT_EQ(ret, CAMERA_OK);
4166 ret = OH_CaptureSession_BeginConfig(captureSession);
4167 EXPECT_EQ(ret, CAMERA_OK);
4168 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4169 EXPECT_EQ(ret, CAMERA_OK);
4170 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4171 ASSERT_NE(photoOutput, nullptr);
4172 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4173 EXPECT_EQ(ret, CAMERA_OK);
4174 if (size != 0 && colorSpace != nullptr) {
4175 ret = OH_CaptureSession_SetActiveColorSpace(captureSession, colorSpace[0]);
4176 EXPECT_EQ(ret, CAMERA_OK);
4177 }
4178 ret = OH_CaptureSession_CommitConfig(captureSession);
4179 EXPECT_EQ(ret, CAMERA_OK);
4180 OH_NativeBuffer_ColorSpace activeColorSpace;
4181 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, &activeColorSpace);
4182 EXPECT_EQ(ret, CAMERA_OK);
4183 if (size != 0 && colorSpace != nullptr) {
4184 ret = OH_CaptureSession_DeleteColorSpaces(captureSession, colorSpace);
4185 EXPECT_EQ(ret, CAMERA_OK);
4186 }
4187 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4188 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4189 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4190 }
4191
4192 /*
4193 * Feature: Framework
4194 * Function: Test set active color space
4195 * SubFunction: NA
4196 * FunctionPoints: NA
4197 * EnvConditions: NA
4198 * CaseDescription: Test set active color space
4199 */
4200 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_046, TestSize.Level0)
4201 {
4202 uint32_t size = 0;
4203 Camera_ErrorCode ret = CAMERA_OK;
4204 OH_NativeBuffer_ColorSpace* colorSpace = nullptr;
4205 Camera_CaptureSession* captureSession = nullptr;
4206 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4207 EXPECT_EQ(ret, CAMERA_OK);
4208 ASSERT_NE(captureSession, nullptr);
4209 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4210 EXPECT_EQ(ret, CAMERA_OK);
4211 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, &size);
4212 EXPECT_EQ(ret, CAMERA_OK);
4213 Camera_Input *cameraInput = nullptr;
4214 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4215 EXPECT_EQ(ret, CAMERA_OK);
4216 ret = OH_CameraInput_Open(cameraInput);
4217 EXPECT_EQ(ret, CAMERA_OK);
4218 ret = OH_CaptureSession_BeginConfig(captureSession);
4219 EXPECT_EQ(ret, CAMERA_OK);
4220 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4221 EXPECT_EQ(ret, CAMERA_OK);
4222 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4223 ASSERT_NE(previewOutput, nullptr);
4224 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4225 EXPECT_EQ(ret, CAMERA_OK);
4226 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4227 ASSERT_NE(photoOutput, nullptr);
4228 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4229 EXPECT_EQ(ret, CAMERA_OK);
4230 if (size != 0 && colorSpace != nullptr) {
4231 ret = OH_CaptureSession_SetActiveColorSpace(captureSession, colorSpace[0]);
4232 EXPECT_EQ(ret, CAMERA_OK);
4233 ret = OH_CaptureSession_SetActiveColorSpace(nullptr, colorSpace[0]);
4234 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4235 }
4236 ret = OH_CaptureSession_CommitConfig(captureSession);
4237 EXPECT_EQ(ret, CAMERA_OK);
4238 OH_NativeBuffer_ColorSpace activeColorSpace;
4239 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, &activeColorSpace);
4240 EXPECT_EQ(ret, CAMERA_OK);
4241 if (size != 0 && colorSpace != nullptr) {
4242 ret = OH_CaptureSession_DeleteColorSpaces(captureSession, colorSpace);
4243 EXPECT_EQ(ret, CAMERA_OK);
4244 }
4245 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4246 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4247 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4248 }
4249
4250 /*
4251 * Feature: Framework
4252 * Function: Test get active color space
4253 * SubFunction: NA
4254 * FunctionPoints: NA
4255 * EnvConditions: NA
4256 * CaseDescription: Test get active color space
4257 */
4258 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_047, TestSize.Level0)
4259 {
4260 uint32_t size = 0;
4261 Camera_ErrorCode ret = CAMERA_OK;
4262 OH_NativeBuffer_ColorSpace* colorSpace = nullptr;
4263 Camera_CaptureSession* captureSession = nullptr;
4264 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4265 EXPECT_EQ(ret, CAMERA_OK);
4266 ASSERT_NE(captureSession, nullptr);
4267 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4268 EXPECT_EQ(ret, CAMERA_OK);
4269 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, &size);
4270 EXPECT_EQ(ret, CAMERA_OK);
4271 Camera_Input *cameraInput = nullptr;
4272 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4273 EXPECT_EQ(ret, CAMERA_OK);
4274 ret = OH_CameraInput_Open(cameraInput);
4275 EXPECT_EQ(ret, CAMERA_OK);
4276 ret = OH_CaptureSession_BeginConfig(captureSession);
4277 EXPECT_EQ(ret, CAMERA_OK);
4278 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4279 EXPECT_EQ(ret, CAMERA_OK);
4280 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4281 ASSERT_NE(previewOutput, nullptr);
4282 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4283 EXPECT_EQ(ret, CAMERA_OK);
4284 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4285 ASSERT_NE(photoOutput, nullptr);
4286 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4287 EXPECT_EQ(ret, CAMERA_OK);
4288 if (size != 0 && colorSpace != nullptr) {
4289 ret = OH_CaptureSession_SetActiveColorSpace(captureSession, colorSpace[0]);
4290 EXPECT_EQ(ret, CAMERA_OK);
4291 }
4292 ret = OH_CaptureSession_CommitConfig(captureSession);
4293 EXPECT_EQ(ret, CAMERA_OK);
4294 OH_NativeBuffer_ColorSpace activeColorSpace;
4295 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, &activeColorSpace);
4296 EXPECT_EQ(ret, CAMERA_OK);
4297 ret = OH_CaptureSession_GetActiveColorSpace(nullptr, &activeColorSpace);
4298 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4299 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, nullptr);
4300 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4301 if (size != 0 && colorSpace != nullptr) {
4302 ret = OH_CaptureSession_DeleteColorSpaces(captureSession, colorSpace);
4303 EXPECT_EQ(ret, CAMERA_OK);
4304 }
4305 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4306 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4307 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4308 }
4309
4310 /*
4311 * Feature: Framework
4312 * Function: Test register smooth zoom information event callback
4313 * SubFunction: NA
4314 * FunctionPoints: NA
4315 * EnvConditions: NA
4316 * CaseDescription: Test register smooth zoom information event callback
4317 */
4318 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_048, TestSize.Level0)
4319 {
4320 Camera_CaptureSession* captureSession = nullptr;
4321 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4322 EXPECT_EQ(ret, CAMERA_OK);
4323 ASSERT_NE(captureSession, nullptr);
4324 CaptureSession_Callbacks setCaptureSessionResultCallback = {
4325 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
4326 .onError = &CameraCaptureSessionOnErrorCb
4327 };
4328 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
4329 EXPECT_EQ(ret, CAMERA_OK);
4330 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4331 EXPECT_EQ(ret, CAMERA_OK);
4332 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(nullptr, CameraCaptureSessionOnSmoothZoomInfoCb);
4333 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4334 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(captureSession, nullptr);
4335 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4336 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4337 EXPECT_EQ(ret, CAMERA_OK);
4338 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
4339 EXPECT_EQ(ret, CAMERA_OK);
4340 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4341 }
4342
4343 /*
4344 * Feature: Framework
4345 * Function: Test unregister smooth zoom information event callback
4346 * SubFunction: NA
4347 * FunctionPoints: NA
4348 * EnvConditions: NA
4349 * CaseDescription: Test unregister smooth zoom information event callback
4350 */
4351 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_049, TestSize.Level0)
4352 {
4353 Camera_CaptureSession* captureSession = nullptr;
4354 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4355 EXPECT_EQ(ret, CAMERA_OK);
4356 ASSERT_NE(captureSession, nullptr);
4357 CaptureSession_Callbacks setCaptureSessionResultCallback = {
4358 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
4359 .onError = &CameraCaptureSessionOnErrorCb
4360 };
4361 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
4362 EXPECT_EQ(ret, CAMERA_OK);
4363 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4364 EXPECT_EQ(ret, CAMERA_OK);
4365 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4366 EXPECT_EQ(ret, CAMERA_OK);
4367 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(nullptr, CameraCaptureSessionOnSmoothZoomInfoCb);
4368 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4369 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(captureSession, nullptr);
4370 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4371 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
4372 EXPECT_EQ(ret, CAMERA_OK);
4373 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4374 }
4375
4376 /*
4377 * Feature: Framework
4378 * Function: Test get supported framerates and delete framerates in preview output
4379 * SubFunction: NA
4380 * FunctionPoints: NA
4381 * EnvConditions: NA
4382 * CaseDescription: Test get supported framerates delete framerates in preview output
4383 */
4384 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_050, TestSize.Level0)
4385 {
4386 uint32_t size = 0;
4387 int32_t minFps = 0;
4388 int32_t maxFps = 0;
4389 Camera_FrameRateRange* frameRateRange = nullptr;
4390 Camera_CaptureSession* captureSession = nullptr;
4391 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4392 EXPECT_EQ(ret, CAMERA_OK);
4393 ASSERT_NE(captureSession, nullptr);
4394 Camera_Input *cameraInput = nullptr;
4395 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4396 ASSERT_NE(cameraInput, nullptr);
4397 EXPECT_EQ(ret, CAMERA_OK);
4398 ret = OH_CameraInput_Open(cameraInput);
4399 EXPECT_EQ(ret, CAMERA_OK);
4400 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4401 ASSERT_NE(previewOutput, nullptr);
4402 ret = OH_PreviewOutput_GetSupportedFrameRates(nullptr, &frameRateRange, &size);
4403 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4404 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, nullptr, &size);
4405 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4406 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, nullptr);
4407 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4408 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, &size);
4409 EXPECT_EQ(ret, CAMERA_OK);
4410 ret = OH_CaptureSession_BeginConfig(captureSession);
4411 EXPECT_EQ(ret, CAMERA_OK);
4412 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4413 EXPECT_EQ(ret, CAMERA_OK);
4414 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4415 EXPECT_EQ(ret, CAMERA_OK);
4416 if (size != 0 && frameRateRange != nullptr) {
4417 ret = OH_PreviewOutput_SetFrameRate(previewOutput, minFps, maxFps);
4418 EXPECT_EQ(ret, CAMERA_OK);
4419 }
4420 ret = OH_CaptureSession_CommitConfig(captureSession);
4421 EXPECT_EQ(ret, CAMERA_OK);
4422 Camera_FrameRateRange activeframeRateRange;
4423 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, &activeframeRateRange);
4424 EXPECT_EQ(ret, CAMERA_OK);
4425 if (size != 0 && frameRateRange != nullptr) {
4426 ret = OH_PreviewOutput_DeleteFrameRates(nullptr, frameRateRange);
4427 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4428 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, nullptr);
4429 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4430 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, frameRateRange);
4431 EXPECT_EQ(ret, CAMERA_OK);
4432 }
4433 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4434 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
4435 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4436 }
4437
4438 /*
4439 * Feature: Framework
4440 * Function: Test set framerate in preview output
4441 * SubFunction: NA
4442 * FunctionPoints: NA
4443 * EnvConditions: NA
4444 * CaseDescription: Test set framerate in preview output
4445 */
4446 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_051, TestSize.Level0)
4447 {
4448 uint32_t size = 0;
4449 int32_t minFps = 0;
4450 int32_t maxFps = 0;
4451 Camera_FrameRateRange* frameRateRange = nullptr;
4452 Camera_CaptureSession* captureSession = nullptr;
4453 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4454 EXPECT_EQ(ret, CAMERA_OK);
4455 ASSERT_NE(captureSession, nullptr);
4456 Camera_Input *cameraInput = nullptr;
4457 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4458 EXPECT_EQ(ret, CAMERA_OK);
4459 ret = OH_CameraInput_Open(cameraInput);
4460 EXPECT_EQ(ret, CAMERA_OK);
4461 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4462 ASSERT_NE(previewOutput, nullptr);
4463 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, &size);
4464 EXPECT_EQ(ret, CAMERA_OK);
4465 ret = OH_CaptureSession_BeginConfig(captureSession);
4466 EXPECT_EQ(ret, CAMERA_OK);
4467 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4468 EXPECT_EQ(ret, CAMERA_OK);
4469 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4470 EXPECT_EQ(ret, CAMERA_OK);
4471 if (size != 0 && frameRateRange != nullptr) {
4472 ret = OH_PreviewOutput_SetFrameRate(nullptr, minFps, maxFps);
4473 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4474 ret = OH_PreviewOutput_SetFrameRate(previewOutput, minFps, maxFps);
4475 EXPECT_EQ(ret, CAMERA_OK);
4476 }
4477 ret = OH_CaptureSession_CommitConfig(captureSession);
4478 EXPECT_EQ(ret, CAMERA_OK);
4479 Camera_FrameRateRange activeframeRateRange;
4480 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, &activeframeRateRange);
4481 EXPECT_EQ(ret, CAMERA_OK);
4482 if (size != 0 && frameRateRange != nullptr) {
4483 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, frameRateRange);
4484 EXPECT_EQ(ret, CAMERA_OK);
4485 }
4486 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4487 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
4488 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4489 }
4490
4491 /*
4492 * Feature: Framework
4493 * Function: Test get active framerate in preview output
4494 * SubFunction: NA
4495 * FunctionPoints: NA
4496 * EnvConditions: NA
4497 * CaseDescription: Test get active framerate in preview output
4498 */
4499 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_052, TestSize.Level0)
4500 {
4501 uint32_t size = 0;
4502 int32_t minFps = 0;
4503 int32_t maxFps = 0;
4504 Camera_FrameRateRange* frameRateRange = nullptr;
4505 Camera_CaptureSession* captureSession = nullptr;
4506 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4507 EXPECT_EQ(ret, CAMERA_OK);
4508 ASSERT_NE(captureSession, nullptr);
4509 Camera_Input *cameraInput = nullptr;
4510 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4511 EXPECT_EQ(ret, CAMERA_OK);
4512 ret = OH_CameraInput_Open(cameraInput);
4513 EXPECT_EQ(ret, CAMERA_OK);
4514 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4515 ASSERT_NE(previewOutput, nullptr);
4516 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, &size);
4517 EXPECT_EQ(ret, CAMERA_OK);
4518 ret = OH_CaptureSession_BeginConfig(captureSession);
4519 EXPECT_EQ(ret, CAMERA_OK);
4520 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4521 EXPECT_EQ(ret, CAMERA_OK);
4522 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4523 EXPECT_EQ(ret, CAMERA_OK);
4524 if (size != 0 && frameRateRange != nullptr) {
4525 ret = OH_PreviewOutput_SetFrameRate(previewOutput, minFps, maxFps);
4526 EXPECT_EQ(ret, CAMERA_OK);
4527 }
4528 ret = OH_CaptureSession_CommitConfig(captureSession);
4529 EXPECT_EQ(ret, CAMERA_OK);
4530 Camera_FrameRateRange activeframeRateRange;
4531 ret = OH_PreviewOutput_GetActiveFrameRate(nullptr, &activeframeRateRange);
4532 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4533 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, nullptr);
4534 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4535 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, &activeframeRateRange);
4536 EXPECT_EQ(ret, CAMERA_OK);
4537 if (size != 0 && frameRateRange != nullptr) {
4538 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, frameRateRange);
4539 EXPECT_EQ(ret, CAMERA_OK);
4540 }
4541 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4542 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
4543 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4544 }
4545
4546 /*
4547 * Feature: Framework
4548 * Function: Test register photo output capture start event callback
4549 * SubFunction: NA
4550 * FunctionPoints: NA
4551 * EnvConditions: NA
4552 * CaseDescription: Test register photo output capture start event callback
4553 */
4554 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_053, TestSize.Level0)
4555 {
4556 Camera_CaptureSession* captureSession = nullptr;
4557 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4558 EXPECT_EQ(ret, CAMERA_OK);
4559 ASSERT_NE(captureSession, nullptr);
4560 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4561 EXPECT_EQ(ret, CAMERA_OK);
4562 Camera_Input *cameraInput = nullptr;
4563 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4564 EXPECT_EQ(ret, CAMERA_OK);
4565 ret = OH_CameraInput_Open(cameraInput);
4566 EXPECT_EQ(ret, CAMERA_OK);
4567 ret = OH_CaptureSession_BeginConfig(captureSession);
4568 EXPECT_EQ(ret, CAMERA_OK);
4569 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4570 EXPECT_EQ(ret, CAMERA_OK);
4571 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4572 ASSERT_NE(photoOutput, nullptr);
4573 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4574 EXPECT_EQ(ret, CAMERA_OK);
4575 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(nullptr, CameraPhotoOutptOnCaptureStartWithInfoCb);
4576 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4577 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(photoOutput, nullptr);
4578 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4579 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4580 EXPECT_EQ(ret, CAMERA_OK);
4581 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4582 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4583 EXPECT_EQ(ret, CAMERA_OK);
4584 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4585 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4586 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4587 }
4588
4589 /*
4590 * Feature: Framework
4591 * Function: Test unregister photo output capture start event callback
4592 * SubFunction: NA
4593 * FunctionPoints: NA
4594 * EnvConditions: NA
4595 * CaseDescription: Test unregister photo output capture start event callback
4596 */
4597 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_054, TestSize.Level0)
4598 {
4599 Camera_CaptureSession* captureSession = nullptr;
4600 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4601 EXPECT_EQ(ret, CAMERA_OK);
4602 ASSERT_NE(captureSession, nullptr);
4603 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4604 EXPECT_EQ(ret, CAMERA_OK);
4605 Camera_Input *cameraInput = nullptr;
4606 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4607 EXPECT_EQ(ret, CAMERA_OK);
4608 ret = OH_CameraInput_Open(cameraInput);
4609 EXPECT_EQ(ret, CAMERA_OK);
4610 ret = OH_CaptureSession_BeginConfig(captureSession);
4611 EXPECT_EQ(ret, CAMERA_OK);
4612 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4613 EXPECT_EQ(ret, CAMERA_OK);
4614 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4615 ASSERT_NE(photoOutput, nullptr);
4616 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4617 EXPECT_EQ(ret, CAMERA_OK);
4618 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4619 EXPECT_EQ(ret, CAMERA_OK);
4620 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4621 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4622 EXPECT_EQ(ret, CAMERA_OK);
4623 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(nullptr, CameraPhotoOutptOnCaptureStartWithInfoCb);
4624 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4625 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(photoOutput, nullptr);
4626 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4627 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4628 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4629 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4630 }
4631
4632 /*
4633 * Feature: Framework
4634 * Function: Test register photo output capture end event callback
4635 * SubFunction: NA
4636 * FunctionPoints: NA
4637 * EnvConditions: NA
4638 * CaseDescription: Test register photo output capture end event callback
4639 */
4640 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_055, TestSize.Level0)
4641 {
4642 Camera_CaptureSession* captureSession = nullptr;
4643 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4644 EXPECT_EQ(ret, CAMERA_OK);
4645 ASSERT_NE(captureSession, nullptr);
4646 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4647 EXPECT_EQ(ret, CAMERA_OK);
4648 Camera_Input *cameraInput = nullptr;
4649 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4650 EXPECT_EQ(ret, CAMERA_OK);
4651 ret = OH_CameraInput_Open(cameraInput);
4652 EXPECT_EQ(ret, CAMERA_OK);
4653 ret = OH_CaptureSession_BeginConfig(captureSession);
4654 EXPECT_EQ(ret, CAMERA_OK);
4655 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4656 EXPECT_EQ(ret, CAMERA_OK);
4657 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4658 ASSERT_NE(photoOutput, nullptr);
4659 ret = OH_PhotoOutput_RegisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4660 EXPECT_EQ(ret, CAMERA_OK);
4661 ret = OH_PhotoOutput_RegisterCaptureEndCallback(nullptr, CameraPhotoOutptOnCaptureEndCb);
4662 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4663 ret = OH_PhotoOutput_RegisterCaptureEndCallback(photoOutput, nullptr);
4664 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4665 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4666 EXPECT_EQ(ret, CAMERA_OK);
4667 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4668 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4669 EXPECT_EQ(ret, CAMERA_OK);
4670 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4671 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4672 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4673 }
4674
4675 /*
4676 * Feature: Framework
4677 * Function: Test unregister photo output capture end event callback
4678 * SubFunction: NA
4679 * FunctionPoints: NA
4680 * EnvConditions: NA
4681 * CaseDescription: Test unregister photo output capture end event callback
4682 */
4683 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_056, TestSize.Level0)
4684 {
4685 Camera_CaptureSession* captureSession = nullptr;
4686 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4687 EXPECT_EQ(ret, CAMERA_OK);
4688 ASSERT_NE(captureSession, nullptr);
4689 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4690 EXPECT_EQ(ret, CAMERA_OK);
4691 Camera_Input *cameraInput = nullptr;
4692 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4693 EXPECT_EQ(ret, CAMERA_OK);
4694 ret = OH_CameraInput_Open(cameraInput);
4695 EXPECT_EQ(ret, CAMERA_OK);
4696 ret = OH_CaptureSession_BeginConfig(captureSession);
4697 EXPECT_EQ(ret, CAMERA_OK);
4698 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4699 EXPECT_EQ(ret, CAMERA_OK);
4700 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4701 ASSERT_NE(photoOutput, nullptr);
4702 ret = OH_PhotoOutput_RegisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4703 EXPECT_EQ(ret, CAMERA_OK);
4704 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4705 EXPECT_EQ(ret, CAMERA_OK);
4706 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4707 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4708 EXPECT_EQ(ret, CAMERA_OK);
4709 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(nullptr, CameraPhotoOutptOnCaptureEndCb);
4710 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4711 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(photoOutput, nullptr);
4712 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4713 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4714 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4715 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4716 }
4717
4718 /*
4719 * Feature: Framework
4720 * Function: Test register photo output shutter end event callback
4721 * SubFunction: NA
4722 * FunctionPoints: NA
4723 * EnvConditions: NA
4724 * CaseDescription: Test register photo output shutter end event callback
4725 */
4726 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_057, TestSize.Level0)
4727 {
4728 Camera_CaptureSession* captureSession = nullptr;
4729 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4730 EXPECT_EQ(ret, CAMERA_OK);
4731 ASSERT_NE(captureSession, nullptr);
4732 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4733 EXPECT_EQ(ret, CAMERA_OK);
4734 Camera_Input *cameraInput = nullptr;
4735 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4736 EXPECT_EQ(ret, CAMERA_OK);
4737 ret = OH_CameraInput_Open(cameraInput);
4738 EXPECT_EQ(ret, CAMERA_OK);
4739 ret = OH_CaptureSession_BeginConfig(captureSession);
4740 EXPECT_EQ(ret, CAMERA_OK);
4741 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4742 EXPECT_EQ(ret, CAMERA_OK);
4743 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4744 ASSERT_NE(photoOutput, nullptr);
4745 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4746 EXPECT_EQ(ret, CAMERA_OK);
4747 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(nullptr, CameraPhotoOutptOnFrameShutterEndCb);
4748 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4749 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(photoOutput, nullptr);
4750 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4751 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4752 EXPECT_EQ(ret, CAMERA_OK);
4753 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4754 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4755 EXPECT_EQ(ret, CAMERA_OK);
4756 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4757 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4758 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4759 }
4760
4761 /*
4762 * Feature: Framework
4763 * Function: Test unregister photo output frame shutter end event callback
4764 * SubFunction: NA
4765 * FunctionPoints: NA
4766 * EnvConditions: NA
4767 * CaseDescription: Test unregister photo output frame shutter end event callback
4768 */
4769 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_058, TestSize.Level0)
4770 {
4771 Camera_CaptureSession* captureSession = nullptr;
4772 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4773 EXPECT_EQ(ret, CAMERA_OK);
4774 ASSERT_NE(captureSession, nullptr);
4775 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4776 EXPECT_EQ(ret, CAMERA_OK);
4777 Camera_Input *cameraInput = nullptr;
4778 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4779 EXPECT_EQ(ret, CAMERA_OK);
4780 ret = OH_CameraInput_Open(cameraInput);
4781 EXPECT_EQ(ret, CAMERA_OK);
4782 ret = OH_CaptureSession_BeginConfig(captureSession);
4783 EXPECT_EQ(ret, CAMERA_OK);
4784 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4785 EXPECT_EQ(ret, CAMERA_OK);
4786 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4787 ASSERT_NE(photoOutput, nullptr);
4788 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4789 EXPECT_EQ(ret, CAMERA_OK);
4790 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4791 EXPECT_EQ(ret, CAMERA_OK);
4792 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4793 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4794 EXPECT_EQ(ret, CAMERA_OK);
4795 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(nullptr, CameraPhotoOutptOnFrameShutterEndCb);
4796 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4797 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(photoOutput, nullptr);
4798 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4799 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4800 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4801 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4802 }
4803
4804 /*
4805 * Feature: Framework
4806 * Function: Test register photo output capture ready event callback
4807 * SubFunction: NA
4808 * FunctionPoints: NA
4809 * EnvConditions: NA
4810 * CaseDescription: Test register photo output capture ready event callback
4811 */
4812 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_059, TestSize.Level0)
4813 {
4814 Camera_CaptureSession* captureSession = nullptr;
4815 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4816 EXPECT_EQ(ret, CAMERA_OK);
4817 ASSERT_NE(captureSession, nullptr);
4818 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4819 EXPECT_EQ(ret, CAMERA_OK);
4820 Camera_Input *cameraInput = nullptr;
4821 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4822 EXPECT_EQ(ret, CAMERA_OK);
4823 ret = OH_CameraInput_Open(cameraInput);
4824 EXPECT_EQ(ret, CAMERA_OK);
4825 ret = OH_CaptureSession_BeginConfig(captureSession);
4826 EXPECT_EQ(ret, CAMERA_OK);
4827 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4828 EXPECT_EQ(ret, CAMERA_OK);
4829 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4830 ASSERT_NE(photoOutput, nullptr);
4831 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4832 EXPECT_EQ(ret, CAMERA_OK);
4833 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(nullptr, CameraPhotoOutptOnCaptureReadyCb);
4834 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4835 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(photoOutput, nullptr);
4836 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4837 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4838 EXPECT_EQ(ret, CAMERA_OK);
4839 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4840 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4841 EXPECT_EQ(ret, CAMERA_OK);
4842 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(nullptr, CameraPhotoOutptOnCaptureReadyCb);
4843 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4844 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, nullptr);
4845 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4846 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4847 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4848 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4849 }
4850
4851 /*
4852 * Feature: Framework
4853 * Function: Test unregister photo output capture ready event callback
4854 * SubFunction: NA
4855 * FunctionPoints: NA
4856 * EnvConditions: NA
4857 * CaseDescription: Test unregister photo output capture ready event callback
4858 */
4859 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_060, TestSize.Level0)
4860 {
4861 Camera_CaptureSession* captureSession = nullptr;
4862 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4863 EXPECT_EQ(ret, CAMERA_OK);
4864 ASSERT_NE(captureSession, nullptr);
4865 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4866 EXPECT_EQ(ret, CAMERA_OK);
4867 Camera_Input *cameraInput = nullptr;
4868 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4869 EXPECT_EQ(ret, CAMERA_OK);
4870 ret = OH_CameraInput_Open(cameraInput);
4871 EXPECT_EQ(ret, CAMERA_OK);
4872 ret = OH_CaptureSession_BeginConfig(captureSession);
4873 EXPECT_EQ(ret, CAMERA_OK);
4874 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4875 EXPECT_EQ(ret, CAMERA_OK);
4876 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4877 ASSERT_NE(photoOutput, nullptr);
4878 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4879 EXPECT_EQ(ret, CAMERA_OK);
4880 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4881 EXPECT_EQ(ret, CAMERA_OK);
4882 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4883 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4884 EXPECT_EQ(ret, CAMERA_OK);
4885 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(nullptr, CameraPhotoOutptOnCaptureReadyCb);
4886 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4887 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, nullptr);
4888 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4889 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4890 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4891 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4892 }
4893
4894 /*
4895 * Feature: Framework
4896 * Function: Test register photo output estimated capture duration event callback
4897 * SubFunction: NA
4898 * FunctionPoints: NA
4899 * EnvConditions: NA
4900 * CaseDescription: Test register photo output estimated capture duration event callback
4901 */
4902 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_061, TestSize.Level0)
4903 {
4904 Camera_CaptureSession* captureSession = nullptr;
4905 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4906 EXPECT_EQ(ret, CAMERA_OK);
4907 ASSERT_NE(captureSession, nullptr);
4908 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4909 EXPECT_EQ(ret, CAMERA_OK);
4910 Camera_Input *cameraInput = nullptr;
4911 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4912 EXPECT_EQ(ret, CAMERA_OK);
4913 ret = OH_CameraInput_Open(cameraInput);
4914 EXPECT_EQ(ret, CAMERA_OK);
4915 ret = OH_CaptureSession_BeginConfig(captureSession);
4916 EXPECT_EQ(ret, CAMERA_OK);
4917 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4918 EXPECT_EQ(ret, CAMERA_OK);
4919 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4920 ASSERT_NE(photoOutput, nullptr);
4921 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(photoOutput,
4922 CameraPhotoOutptEstimatedOnCaptureDurationCb);
4923 EXPECT_EQ(ret, CAMERA_OK);
4924 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(nullptr,
4925 CameraPhotoOutptEstimatedOnCaptureDurationCb);
4926 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4927 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(photoOutput, nullptr);
4928 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4929 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4930 EXPECT_EQ(ret, CAMERA_OK);
4931 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4932 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(photoOutput,
4933 CameraPhotoOutptEstimatedOnCaptureDurationCb);
4934 EXPECT_EQ(ret, CAMERA_OK);
4935 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4936 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4937 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4938 }
4939
4940 /*
4941 * Feature: Framework
4942 * Function: Test unregister photo output estimated capture duration event callback
4943 * SubFunction: NA
4944 * FunctionPoints: NA
4945 * EnvConditions: NA
4946 * CaseDescription: Test unregister photo output estimated capture duration event callback
4947 */
4948 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_062, TestSize.Level0)
4949 {
4950 Camera_CaptureSession* captureSession = nullptr;
4951 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4952 EXPECT_EQ(ret, CAMERA_OK);
4953 ASSERT_NE(captureSession, nullptr);
4954 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4955 EXPECT_EQ(ret, CAMERA_OK);
4956 Camera_Input *cameraInput = nullptr;
4957 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4958 EXPECT_EQ(ret, CAMERA_OK);
4959 ret = OH_CameraInput_Open(cameraInput);
4960 EXPECT_EQ(ret, CAMERA_OK);
4961 ret = OH_CaptureSession_BeginConfig(captureSession);
4962 EXPECT_EQ(ret, CAMERA_OK);
4963 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4964 EXPECT_EQ(ret, CAMERA_OK);
4965 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4966 ASSERT_NE(photoOutput, nullptr);
4967 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(photoOutput,
4968 CameraPhotoOutptEstimatedOnCaptureDurationCb);
4969 EXPECT_EQ(ret, CAMERA_OK);
4970 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4971 EXPECT_EQ(ret, CAMERA_OK);
4972 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4973 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(photoOutput,
4974 CameraPhotoOutptEstimatedOnCaptureDurationCb);
4975 EXPECT_EQ(ret, CAMERA_OK);
4976 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(nullptr,
4977 CameraPhotoOutptEstimatedOnCaptureDurationCb);
4978 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4979 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(photoOutput, nullptr);
4980 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4981 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4982 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4983 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4984 }
4985
4986 /*
4987 * Feature: Framework
4988 * Function: Test get supported framerates and delete framerates in video output
4989 * SubFunction: NA
4990 * FunctionPoints: NA
4991 * EnvConditions: NA
4992 * CaseDescription: Test get supported framerates and delete framerates in video output
4993 */
4994 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_063, TestSize.Level0)
4995 {
4996 uint32_t size = 0;
4997 int32_t minFps = 0;
4998 int32_t maxFps = 0;
4999 Camera_FrameRateRange* frameRateRange = nullptr;
5000 Camera_CaptureSession* captureSession = nullptr;
5001 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5002 EXPECT_EQ(ret, CAMERA_OK);
5003 ASSERT_NE(captureSession, nullptr);
5004 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
5005 EXPECT_EQ(ret, CAMERA_OK);
5006 Camera_Input *cameraInput = nullptr;
5007 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5008 EXPECT_EQ(ret, CAMERA_OK);
5009 ret = OH_CameraInput_Open(cameraInput);
5010 EXPECT_EQ(ret, CAMERA_OK);
5011 Camera_VideoOutput* videoOutput = CreateVideoOutput();
5012 ASSERT_NE(videoOutput, nullptr);
5013 ret = OH_VideoOutput_GetSupportedFrameRates(nullptr, &frameRateRange, &size);
5014 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5015 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, nullptr, &size);
5016 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5017 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, nullptr);
5018 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5019 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, &size);
5020 EXPECT_EQ(ret, CAMERA_OK);
5021 ret = OH_CaptureSession_BeginConfig(captureSession);
5022 EXPECT_EQ(ret, CAMERA_OK);
5023 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5024 EXPECT_EQ(ret, CAMERA_OK);
5025 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
5026 EXPECT_EQ(ret, CAMERA_OK);
5027 if (size != 0 && frameRateRange != nullptr) {
5028 ret = OH_VideoOutput_SetFrameRate(videoOutput, minFps, maxFps);
5029 EXPECT_EQ(ret, CAMERA_OK);
5030 }
5031 ret = OH_CaptureSession_CommitConfig(captureSession);
5032 EXPECT_EQ(ret, CAMERA_OK);
5033 Camera_FrameRateRange activeframeRateRange;
5034 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, &activeframeRateRange);
5035 EXPECT_EQ(ret, CAMERA_OK);
5036 if (size != 0 && frameRateRange != nullptr) {
5037 ret = OH_VideoOutput_DeleteFrameRates(nullptr, frameRateRange);
5038 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5039 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, nullptr);
5040 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5041 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, frameRateRange);
5042 EXPECT_EQ(ret, CAMERA_OK);
5043 }
5044 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5045 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
5046 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5047 }
5048
5049 /*
5050 * Feature: Framework
5051 * Function: Test set framerate in video output
5052 * SubFunction: NA
5053 * FunctionPoints: NA
5054 * EnvConditions: NA
5055 * CaseDescription: Test set framerate in video output
5056 */
5057 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_064, TestSize.Level0)
5058 {
5059 uint32_t size = 0;
5060 int32_t minFps = 0;
5061 int32_t maxFps = 0;
5062 Camera_FrameRateRange* frameRateRange = nullptr;
5063 Camera_CaptureSession* captureSession = nullptr;
5064 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5065 EXPECT_EQ(ret, CAMERA_OK);
5066 ASSERT_NE(captureSession, nullptr);
5067 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
5068 EXPECT_EQ(ret, CAMERA_OK);
5069 Camera_Input *cameraInput = nullptr;
5070 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5071 EXPECT_EQ(ret, CAMERA_OK);
5072 ret = OH_CameraInput_Open(cameraInput);
5073 EXPECT_EQ(ret, CAMERA_OK);
5074 Camera_VideoOutput* videoOutput = CreateVideoOutput();
5075 ASSERT_NE(videoOutput, nullptr);
5076 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, &size);
5077 EXPECT_EQ(ret, CAMERA_OK);
5078 ret = OH_CaptureSession_BeginConfig(captureSession);
5079 EXPECT_EQ(ret, CAMERA_OK);
5080 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5081 EXPECT_EQ(ret, CAMERA_OK);
5082 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
5083 EXPECT_EQ(ret, 0);
5084 if (size != 0 && frameRateRange != nullptr) {
5085 ret = OH_VideoOutput_SetFrameRate(nullptr, minFps, maxFps);
5086 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5087 ret = OH_VideoOutput_SetFrameRate(videoOutput, minFps, maxFps);
5088 EXPECT_EQ(ret, CAMERA_OK);
5089 }
5090 ret = OH_CaptureSession_CommitConfig(captureSession);
5091 EXPECT_EQ(ret, CAMERA_OK);
5092 Camera_FrameRateRange activeframeRateRange;
5093 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, &activeframeRateRange);
5094 EXPECT_EQ(ret, CAMERA_OK);
5095 if (size != 0 && frameRateRange != nullptr) {
5096 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, frameRateRange);
5097 EXPECT_EQ(ret, CAMERA_OK);
5098 }
5099 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5100 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
5101 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5102 }
5103
5104 /*
5105 * Feature: Framework
5106 * Function: Test get active framerate in video output
5107 * SubFunction: NA
5108 * FunctionPoints: NA
5109 * EnvConditions: NA
5110 * CaseDescription: Test get active framerate in video output
5111 */
5112 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_065, TestSize.Level0)
5113 {
5114 uint32_t size = 0;
5115 int32_t minFps = 0;
5116 int32_t maxFps = 0;
5117 Camera_FrameRateRange* frameRateRange = nullptr;
5118 Camera_CaptureSession* captureSession = nullptr;
5119 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5120 EXPECT_EQ(ret, CAMERA_OK);
5121 ASSERT_NE(captureSession, nullptr);
5122 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
5123 EXPECT_EQ(ret, CAMERA_OK);
5124 Camera_Input *cameraInput = nullptr;
5125 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5126 EXPECT_EQ(ret, CAMERA_OK);
5127 ret = OH_CameraInput_Open(cameraInput);
5128 EXPECT_EQ(ret, CAMERA_OK);
5129 Camera_VideoOutput* videoOutput = CreateVideoOutput();
5130 ASSERT_NE(videoOutput, nullptr);
5131 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, &size);
5132 EXPECT_EQ(ret, CAMERA_OK);
5133 ret = OH_CaptureSession_BeginConfig(captureSession);
5134 EXPECT_EQ(ret, CAMERA_OK);
5135 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5136 EXPECT_EQ(ret, CAMERA_OK);
5137 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
5138 EXPECT_EQ(ret, CAMERA_OK);
5139 if (size != 0 && frameRateRange != nullptr) {
5140 ret = OH_VideoOutput_SetFrameRate(videoOutput, minFps, maxFps);
5141 EXPECT_EQ(ret, CAMERA_OK);
5142 }
5143 ret = OH_CaptureSession_CommitConfig(captureSession);
5144 EXPECT_EQ(ret, CAMERA_OK);
5145 Camera_FrameRateRange activeframeRateRange;
5146 ret = OH_VideoOutput_GetActiveFrameRate(nullptr, &activeframeRateRange);
5147 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5148 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, nullptr);
5149 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5150 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, &activeframeRateRange);
5151 EXPECT_EQ(ret, CAMERA_OK);
5152 if (size != 0 && frameRateRange != nullptr) {
5153 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, frameRateRange);
5154 EXPECT_EQ(ret, CAMERA_OK);
5155 }
5156 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5157 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
5158 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5159 }
5160
5161 /*
5162 * Feature: Framework
5163 * Function: Test create photo output without surface
5164 * SubFunction: NA
5165 * FunctionPoints: NA
5166 * EnvConditions: NA
5167 * CaseDescription: Test create photo output without surface
5168 */
5169 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_066, TestSize.Level0)
5170 {
5171 Camera_Size photoSize = {
5172 .width = 10,
5173 .height = 10
5174 };
5175 Camera_Profile profile = {
5176 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5177 .size = photoSize
5178 };
5179 Camera_CaptureSession* captureSession = nullptr;
5180 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5181 EXPECT_EQ(ret, CAMERA_OK);
5182 ASSERT_NE(captureSession, nullptr);
5183 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5184 EXPECT_EQ(ret, CAMERA_OK);
5185 ret = OH_CaptureSession_BeginConfig(captureSession);
5186 EXPECT_EQ(ret, CAMERA_OK);
5187 Camera_Input *cameraInput = nullptr;
5188 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5189 EXPECT_EQ(ret, CAMERA_OK);
5190 ASSERT_NE(&cameraInput, nullptr);
5191 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
5192 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
5193 Camera_PhotoOutput *photoOutput = nullptr;
5194 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(nullptr, &profile, &photoOutput);
5195 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5196 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, nullptr, &photoOutput);
5197 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5198 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, nullptr);
5199 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5200 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5201 EXPECT_EQ(ret, CAMERA_OK);
5202 ASSERT_NE(photoOutput, nullptr);
5203 bool isSuccessful = false;
5204 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5205 EXPECT_EQ(ret, CAMERA_OK);
5206 if (isSuccessful == true) {
5207 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5208 EXPECT_EQ(ret, CAMERA_OK);
5209 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5210 }
5211 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5212 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5213 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5214 }
5215
5216 /*
5217 * Feature: Framework
5218 * Function: Test register photo available callback
5219 * SubFunction: NA
5220 * FunctionPoints: NA
5221 * EnvConditions: NA
5222 * CaseDescription: Test register photo available callback
5223 */
5224 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_067, TestSize.Level0)
5225 {
5226 Camera_Size photoSize = {
5227 .width = 10,
5228 .height = 10
5229 };
5230 Camera_Profile profile = {
5231 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5232 .size = photoSize
5233 };
5234 Camera_CaptureSession* captureSession = nullptr;
5235 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5236 EXPECT_EQ(ret, CAMERA_OK);
5237 ASSERT_NE(captureSession, nullptr);
5238 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5239 EXPECT_EQ(ret, CAMERA_OK);
5240 Camera_Input *cameraInput = nullptr;
5241 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5242 EXPECT_EQ(ret, CAMERA_OK);
5243 ret = OH_CameraInput_Open(cameraInput);
5244 EXPECT_EQ(ret, CAMERA_OK);
5245 ret = OH_CaptureSession_BeginConfig(captureSession);
5246 EXPECT_EQ(ret, CAMERA_OK);
5247 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5248 EXPECT_EQ(ret, CAMERA_OK);
5249 Camera_PhotoOutput *photoOutput = nullptr;
5250 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5251 EXPECT_EQ(ret, CAMERA_OK);
5252 bool isSuccessful = false;
5253 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5254 EXPECT_EQ(ret, CAMERA_OK);
5255 if (isSuccessful == true) {
5256 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5257 EXPECT_EQ(ret, CAMERA_OK);
5258 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5259 EXPECT_EQ(ret, CAMERA_OK);
5260 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5261 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5262 EXPECT_EQ(ret, CAMERA_OK);
5263 } else {
5264 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(photoOutput, nullptr);
5265 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5266 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAvailableCb);
5267 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5268 }
5269 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5270 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5271 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5272 }
5273
5274 /*
5275 * Feature: Framework
5276 * Function: Test unregister photo available callback
5277 * SubFunction: NA
5278 * FunctionPoints: NA
5279 * EnvConditions: NA
5280 * CaseDescription: Test unregister photo available callback
5281 */
5282 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_068, TestSize.Level0)
5283 {
5284 Camera_Size photoSize = {
5285 .width = 10,
5286 .height = 10
5287 };
5288 Camera_Profile profile = {
5289 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5290 .size = photoSize
5291 };
5292 Camera_CaptureSession* captureSession = nullptr;
5293 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5294 EXPECT_EQ(ret, CAMERA_OK);
5295 ASSERT_NE(captureSession, nullptr);
5296 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5297 EXPECT_EQ(ret, CAMERA_OK);
5298 Camera_Input *cameraInput = nullptr;
5299 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5300 EXPECT_EQ(ret, CAMERA_OK);
5301 ret = OH_CameraInput_Open(cameraInput);
5302 EXPECT_EQ(ret, CAMERA_OK);
5303 ret = OH_CaptureSession_BeginConfig(captureSession);
5304 EXPECT_EQ(ret, CAMERA_OK);
5305 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5306 EXPECT_EQ(ret, CAMERA_OK);
5307 Camera_PhotoOutput *photoOutput = nullptr;
5308 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5309 EXPECT_EQ(ret, CAMERA_OK);
5310 bool isSuccessful = false;
5311 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5312 EXPECT_EQ(ret, CAMERA_OK);
5313 if (isSuccessful == true) {
5314 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5315 EXPECT_EQ(ret, CAMERA_OK);
5316 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5317 EXPECT_EQ(ret, CAMERA_OK);
5318 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5319 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5320 EXPECT_EQ(ret, CAMERA_OK);
5321 } else {
5322 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAvailableCb);
5323 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5324 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(photoOutput, nullptr);
5325 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5326 }
5327 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5328 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5329 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5330 }
5331
5332 /*
5333 * Feature: Framework
5334 * Function: Test register photo asset available callback
5335 * SubFunction: NA
5336 * FunctionPoints: NA
5337 * EnvConditions: NA
5338 * CaseDescription: Test register photo asset available callback
5339 */
5340 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_069, TestSize.Level0)
5341 {
5342 Camera_Size photoSize = {
5343 .width = 10,
5344 .height = 10
5345 };
5346 Camera_Profile profile = {
5347 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5348 .size = photoSize
5349 };
5350 Camera_CaptureSession* captureSession = nullptr;
5351 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5352 EXPECT_EQ(ret, CAMERA_OK);
5353 ASSERT_NE(captureSession, nullptr);
5354 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5355 EXPECT_EQ(ret, CAMERA_OK);
5356 Camera_Input *cameraInput = nullptr;
5357 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5358 EXPECT_EQ(ret, CAMERA_OK);
5359 ret = OH_CameraInput_Open(cameraInput);
5360 EXPECT_EQ(ret, CAMERA_OK);
5361 ret = OH_CaptureSession_BeginConfig(captureSession);
5362 EXPECT_EQ(ret, CAMERA_OK);
5363 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5364 EXPECT_EQ(ret, CAMERA_OK);
5365 Camera_PhotoOutput *photoOutput = nullptr;
5366 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5367 EXPECT_EQ(ret, CAMERA_OK);
5368 bool isSuccessful = false;
5369 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5370 EXPECT_EQ(ret, CAMERA_OK);
5371 if (isSuccessful == true) {
5372 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAssetAvailableCb);
5373 EXPECT_EQ(ret, CAMERA_OK);
5374 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5375 EXPECT_EQ(ret, CAMERA_OK);
5376 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5377 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(photoOutput,
5378 CameraPhotoOutptOnPhotoAssetAvailableCb);
5379 EXPECT_EQ(ret, CAMERA_OK);
5380 } else {
5381 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(photoOutput, nullptr);
5382 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5383 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAssetAvailableCb);
5384 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5385 }
5386 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5387 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5388 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5389 }
5390
5391 /*
5392 * Feature: Framework
5393 * Function: Test unregister photo asset available callback
5394 * SubFunction: NA
5395 * FunctionPoints: NA
5396 * EnvConditions: NA
5397 * CaseDescription: Test unregister photo asset available callback
5398 */
5399 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_070, TestSize.Level0)
5400 {
5401 Camera_Size photoSize = {
5402 .width = 10,
5403 .height = 10
5404 };
5405 Camera_Profile profile = {
5406 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5407 .size = photoSize
5408 };
5409 Camera_CaptureSession* captureSession = nullptr;
5410 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5411 EXPECT_EQ(ret, CAMERA_OK);
5412 ASSERT_NE(captureSession, nullptr);
5413 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5414 EXPECT_EQ(ret, CAMERA_OK);
5415 Camera_Input *cameraInput = nullptr;
5416 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5417 EXPECT_EQ(ret, CAMERA_OK);
5418 ret = OH_CameraInput_Open(cameraInput);
5419 EXPECT_EQ(ret, CAMERA_OK);
5420 ret = OH_CaptureSession_BeginConfig(captureSession);
5421 EXPECT_EQ(ret, CAMERA_OK);
5422 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5423 EXPECT_EQ(ret, CAMERA_OK);
5424 Camera_PhotoOutput *photoOutput = nullptr;
5425 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5426 EXPECT_EQ(ret, CAMERA_OK);
5427 bool isSuccessful = false;
5428 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5429 EXPECT_EQ(ret, CAMERA_OK);
5430 if (isSuccessful == true) {
5431 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAssetAvailableCb);
5432 EXPECT_EQ(ret, CAMERA_OK);
5433 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5434 EXPECT_EQ(ret, CAMERA_OK);
5435 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5436 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(photoOutput,
5437 CameraPhotoOutptOnPhotoAssetAvailableCb);
5438 EXPECT_EQ(ret, CAMERA_OK);
5439 } else {
5440 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAssetAvailableCb);
5441 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5442 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(photoOutput, nullptr);
5443 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5444 }
5445 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5446 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5447 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5448 }
5449
5450 /*
5451 * Feature: Framework
5452 * Function: Test moving photo supported or not
5453 * SubFunction: NA
5454 * FunctionPoints: NA
5455 * EnvConditions: NA
5456 * CaseDescription: Test moving photo supported or not
5457 */
5458 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_071, TestSize.Level0)
5459 {
5460 Camera_CaptureSession* captureSession = nullptr;
5461 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5462 EXPECT_EQ(ret, CAMERA_OK);
5463 ASSERT_NE(captureSession, nullptr);
5464 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5465 EXPECT_EQ(ret, CAMERA_OK);
5466 ret = OH_CaptureSession_BeginConfig(captureSession);
5467 EXPECT_EQ(ret, CAMERA_OK);
5468 Camera_Input *cameraInput = nullptr;
5469 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5470 EXPECT_EQ(ret, CAMERA_OK);
5471 ASSERT_NE(&cameraInput, nullptr);
5472 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
5473 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
5474 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
5475 ASSERT_NE(photooutput, nullptr);
5476 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
5477 EXPECT_EQ(ret, CAMERA_OK);
5478 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5479 bool isSupported = false;
5480 ret = OH_PhotoOutput_IsMovingPhotoSupported(photooutput, &isSupported);
5481 EXPECT_EQ(ret, CAMERA_OK);
5482 if (isSupported == true) {
5483 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, true);
5484 EXPECT_EQ(ret, CAMERA_OK);
5485 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, false);
5486 EXPECT_EQ(ret, CAMERA_OK);
5487 } else {
5488 ret = OH_PhotoOutput_IsMovingPhotoSupported(nullptr, &isSupported);
5489 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5490 }
5491 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
5492 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5493 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5494 }
5495
5496 /*
5497 * Feature: Framework
5498 * Function: Test enable moving photo
5499 * SubFunction: NA
5500 * FunctionPoints: NA
5501 * EnvConditions: NA
5502 * CaseDescription: Test enable moving photo
5503 */
5504 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_072, TestSize.Level0)
5505 {
5506 Camera_CaptureSession* captureSession = nullptr;
5507 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5508 EXPECT_EQ(ret, CAMERA_OK);
5509 ASSERT_NE(captureSession, nullptr);
5510 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5511 EXPECT_EQ(ret, CAMERA_OK);
5512 ret = OH_CaptureSession_BeginConfig(captureSession);
5513 EXPECT_EQ(ret, CAMERA_OK);
5514 Camera_Input *cameraInput = nullptr;
5515 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5516 EXPECT_EQ(ret, CAMERA_OK);
5517 ASSERT_NE(&cameraInput, nullptr);
5518 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
5519 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
5520 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
5521 ASSERT_NE(photooutput, nullptr);
5522 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
5523 EXPECT_EQ(ret, CAMERA_OK);
5524 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5525 bool isSupported = false;
5526 ret = OH_PhotoOutput_IsMovingPhotoSupported(photooutput, &isSupported);
5527 EXPECT_EQ(ret, CAMERA_OK);
5528 if (isSupported == true) {
5529 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, true);
5530 EXPECT_EQ(ret, CAMERA_OK);
5531 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, false);
5532 EXPECT_EQ(ret, CAMERA_OK);
5533 ret = OH_PhotoOutput_EnableMovingPhoto(nullptr, true);
5534 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5535 }
5536 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
5537 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5538 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5539 }
5540
5541 /*
5542 * Feature: Framework
5543 * Function: Test get main image in photo native
5544 * SubFunction: NA
5545 * FunctionPoints: NA
5546 * EnvConditions: NA
5547 * CaseDescription: Test get main image in photo native
5548 */
5549 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_073, TestSize.Level0)
5550 {
5551 OH_PhotoNative* photoNative = new OH_PhotoNative();
5552 OH_ImageNative* mainImage = nullptr;
5553 Camera_ErrorCode ret = OH_PhotoNative_GetMainImage(photoNative, &mainImage);
5554 EXPECT_EQ(ret, CAMERA_OK);
5555 ret = OH_PhotoNative_GetMainImage(nullptr, &mainImage);
5556 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5557 ret = OH_PhotoNative_GetMainImage(photoNative, nullptr);
5558 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5559 std::shared_ptr<OHOS::Media::NativeImage> mainImage_ = std::make_shared<OHOS::Media::NativeImage>(nullptr, nullptr);
5560 photoNative->SetMainImage(mainImage_);
5561 ret = OH_PhotoNative_GetMainImage(photoNative, &mainImage);
5562 EXPECT_EQ(ret, CAMERA_OK);
5563 ASSERT_NE(mainImage, nullptr);
5564 EXPECT_EQ(OH_PhotoNative_Release(photoNative), CAMERA_OK);
5565 }
5566
5567 /*
5568 * Feature: Framework
5569 * Function: Test release in photo native
5570 * SubFunction: NA
5571 * FunctionPoints: NA
5572 * EnvConditions: NA
5573 * CaseDescription: Test release in photo native
5574 */
5575 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_074, TestSize.Level0)
5576 {
5577 OH_PhotoNative* photoNative = new OH_PhotoNative();
5578 OH_ImageNative* mainImage = nullptr;
5579 Camera_ErrorCode ret = OH_PhotoNative_GetMainImage(photoNative, &mainImage);
5580 EXPECT_EQ(ret, CAMERA_OK);
5581 ret = OH_PhotoNative_GetMainImage(nullptr, &mainImage);
5582 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5583 ret = OH_PhotoNative_GetMainImage(photoNative, nullptr);
5584 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5585 EXPECT_EQ(OH_PhotoNative_Release(photoNative), CAMERA_OK);
5586 EXPECT_EQ(OH_PhotoNative_Release(nullptr), CAMERA_INVALID_ARGUMENT);
5587 }
5588 } // CameraStandard
5589 } // OHOS