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 location of capture settings
1652 * SubFunction: NA
1653 * FunctionPoints: NA
1654 * EnvConditions: NA
1655 * CaseDescription: Test photo capture with capture settings
1656 */
1657 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_053, TestSize.Level0)
1658 {
1659 Camera_ErrorCode ret = CAMERA_OK;
1660 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1661 EXPECT_NE(PhotoOutput, nullptr);
1662
1663 Camera_CaptureSession* captureSession = nullptr;
1664 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1665 EXPECT_EQ(ret, CAMERA_OK);
1666 EXPECT_NE(captureSession, nullptr);
1667
1668 Camera_Input *cameraInput = nullptr;
1669 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1670 EXPECT_EQ(ret, CAMERA_OK);
1671
1672 ret = OH_CameraInput_Open(cameraInput);
1673 EXPECT_EQ(ret, CAMERA_OK);
1674
1675 ret = OH_CaptureSession_BeginConfig(captureSession);
1676 EXPECT_EQ(ret, 0);
1677
1678 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1679 EXPECT_NE(previewOutput, nullptr);
1680 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1681 EXPECT_EQ(ret, 0);
1682 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1683 EXPECT_EQ(ret, 0);
1684 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1685 EXPECT_EQ(ret, 0);
1686 ret = OH_CaptureSession_CommitConfig(captureSession);
1687 EXPECT_EQ(ret, 0);
1688
1689 Camera_PhotoCaptureSetting capSettings;
1690 capSettings.rotation = IAMGE_ROTATION_90;
1691 Camera_Location location = {1.0, 1.0, 1.0};
1692 capSettings.location = &location;
1693 ret = OH_PhotoOutput_Capture_WithCaptureSetting(PhotoOutput, capSettings);
1694 EXPECT_EQ(ret, 0);
1695 sleep(WAIT_TIME_AFTER_CAPTURE);
1696 location = {0, 0, 0};
1697 capSettings.location = &location;
1698 ret = OH_PhotoOutput_Capture_WithCaptureSetting(PhotoOutput, capSettings);
1699 EXPECT_EQ(ret, 0);
1700
1701 ret = OH_PhotoOutput_Release(PhotoOutput);
1702 EXPECT_EQ(ret, 0);
1703 ret = OH_PreviewOutput_Release(previewOutput);
1704 EXPECT_EQ(ret, 0);
1705 ret = OH_CameraInput_Release(cameraInput);
1706 EXPECT_EQ(ret, 0);
1707 ret = OH_CaptureSession_Release(captureSession);
1708 EXPECT_EQ(ret, 0);
1709 ReleaseImageReceiver();
1710 }
1711
1712 /*
1713 * Feature: Framework
1714 * Function: Test photo capture with capture settings
1715 * SubFunction: NA
1716 * FunctionPoints: NA
1717 * EnvConditions: NA
1718 * CaseDescription: Test photo capture with preview output & capture settings
1719 */
1720 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_054, TestSize.Level0)
1721 {
1722 Camera_ErrorCode ret = CAMERA_OK;
1723 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1724 EXPECT_NE(PhotoOutput, nullptr);
1725 Camera_CaptureSession* captureSession = nullptr;
1726 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1727 EXPECT_EQ(ret, CAMERA_OK);
1728 EXPECT_NE(captureSession, nullptr);
1729 Camera_Input *cameraInput = nullptr;
1730 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1731 EXPECT_EQ(ret, CAMERA_OK);
1732 ret = OH_CameraInput_Open(cameraInput);
1733 EXPECT_EQ(ret, CAMERA_OK);
1734 ret = OH_CaptureSession_BeginConfig(captureSession);
1735 EXPECT_EQ(ret, 0);
1736 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1737 EXPECT_NE(previewOutput, nullptr);
1738 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1739 EXPECT_EQ(ret, 0);
1740 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1741 EXPECT_EQ(ret, 0);
1742 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1743 EXPECT_EQ(ret, 0);
1744 ret = OH_CaptureSession_CommitConfig(captureSession);
1745 EXPECT_EQ(ret, 0);
1746 Camera_PhotoCaptureSetting capSettings;
1747 capSettings.quality = QUALITY_LEVEL_MEDIUM;
1748 capSettings.rotation = IAMGE_ROTATION_90;
1749 ret = OH_PhotoOutput_Capture_WithCaptureSetting(PhotoOutput, capSettings);
1750 EXPECT_EQ(ret, 0);
1751 ret = OH_PhotoOutput_Release(PhotoOutput);
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 ReleaseImageReceiver();
1760 }
1761
1762 /*
1763 * Feature: Framework
1764 * Function: Test capture session with Video Stabilization Mode
1765 * SubFunction: NA
1766 * FunctionPoints: NA
1767 * EnvConditions: NA
1768 * CaseDescription: Test capture session with Video Stabilization Mode
1769 */
1770 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_057, TestSize.Level0)
1771 {
1772 Camera_CaptureSession* captureSession;
1773 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1774 EXPECT_EQ(ret, CAMERA_OK);
1775 EXPECT_NE(captureSession, nullptr);
1776 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1777 EXPECT_EQ(ret, CAMERA_OK);
1778
1779 Camera_Input *cameraInput;
1780 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1781 EXPECT_EQ(ret, CAMERA_OK);
1782 ret = OH_CameraInput_Open(cameraInput);
1783 EXPECT_EQ(ret, CAMERA_OK);
1784 ret = OH_CaptureSession_BeginConfig(captureSession);
1785 EXPECT_EQ(ret, 0);
1786 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1787 EXPECT_EQ(ret, 0);
1788 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1789 EXPECT_NE(previewOutput, nullptr);
1790 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1791 EXPECT_EQ(ret, 0);
1792 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1793 EXPECT_NE(videoOutput, nullptr);
1794 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1795 EXPECT_EQ(ret, 0);
1796 ret = OH_CaptureSession_CommitConfig(captureSession);
1797 EXPECT_EQ(ret, 0);
1798 ret = OH_PreviewOutput_Start(previewOutput);
1799 EXPECT_EQ(ret, 0);
1800 bool isSupported=false;
1801 ret = OH_CaptureSession_IsVideoStabilizationModeSupported(captureSession, STABILIZATION_MODE_MIDDLE, &isSupported);
1802
1803 if (isSupported) {
1804 ret = OH_CaptureSession_SetVideoStabilizationMode(captureSession, STABILIZATION_MODE_MIDDLE);
1805 EXPECT_EQ(ret, 0);
1806 }
1807 ret = OH_VideoOutput_Start(videoOutput);
1808 EXPECT_EQ(ret, 0);
1809 sleep(WAIT_TIME_AFTER_START);
1810 ret = OH_VideoOutput_Stop(videoOutput);
1811 EXPECT_EQ(ret, 0);
1812 ret = OH_VideoOutput_Release(videoOutput);
1813 EXPECT_EQ(ret, 0);
1814 ret = OH_PreviewOutput_Stop(previewOutput);
1815 EXPECT_EQ(ret, 0);
1816 ret = OH_PreviewOutput_Release(previewOutput);
1817 EXPECT_EQ(ret, 0);
1818 ret = OH_CameraInput_Release(cameraInput);
1819 EXPECT_EQ(ret, 0);
1820 ret = OH_CaptureSession_Release(captureSession);
1821 EXPECT_EQ(ret, 0);
1822 }
1823
1824 /*
1825 * Feature: Framework
1826 * Function: Test add preview,video and photo output,set location,video start do capture
1827 * SubFunction: NA
1828 * FunctionPoints: NA
1829 * EnvConditions: NA
1830 * CaseDescription: Test add preview video and photo output, video start do capture
1831 */
1832 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_058, TestSize.Level0)
1833 {
1834 Camera_CaptureSession* captureSession = nullptr;
1835 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1836 EXPECT_EQ(ret, CAMERA_OK);
1837 EXPECT_NE(captureSession, nullptr);
1838 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1839 EXPECT_EQ(ret, CAMERA_OK);
1840 Camera_Input *cameraInput = nullptr;
1841 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1842 EXPECT_EQ(ret, CAMERA_OK);
1843 ret = OH_CameraInput_Open(cameraInput);
1844 EXPECT_EQ(ret, CAMERA_OK);
1845 EXPECT_NE(&cameraInput, nullptr);
1846 ret = OH_CaptureSession_BeginConfig(captureSession);
1847 EXPECT_EQ(ret, 0);
1848 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1849 EXPECT_EQ(ret, 0);
1850 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1851 EXPECT_NE(videoOutput, nullptr);
1852 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1853 EXPECT_NE(photoOutput, nullptr);
1854 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1855 EXPECT_NE(previewOutput, nullptr);
1856 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1857 EXPECT_EQ(ret, 0);
1858 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1859 EXPECT_EQ(ret, 0);
1860 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1861 EXPECT_EQ(ret, 0);
1862 ret = OH_CaptureSession_CommitConfig(captureSession);
1863 EXPECT_EQ(ret, 0);
1864 ret = OH_VideoOutput_Start(videoOutput);
1865 EXPECT_EQ(ret, 0);
1866
1867 Camera_PhotoCaptureSetting capSettings;
1868 capSettings.quality = QUALITY_LEVEL_MEDIUM;
1869
1870 Camera_Location location = {1.0, 1.0, 1.0};
1871 capSettings.location = &location;
1872 ret = OH_PhotoOutput_Capture_WithCaptureSetting(photoOutput, capSettings);
1873 EXPECT_EQ(ret, 0);
1874
1875 ret = OH_VideoOutput_Stop(videoOutput);
1876 EXPECT_EQ(ret, 0);
1877 ret = OH_VideoOutput_Release(videoOutput);
1878 EXPECT_EQ(ret, 0);
1879 ret = OH_PhotoOutput_Release(photoOutput);
1880 EXPECT_EQ(ret, CAMERA_OK);
1881 ret = OH_CameraInput_Release(cameraInput);
1882 EXPECT_EQ(ret, 0);
1883 ret = OH_CaptureSession_Release(captureSession);
1884 EXPECT_EQ(ret, 0);
1885 ReleaseImageReceiver();
1886 }
1887
1888 /*
1889 * Feature: Framework
1890 * Function: Test add preview,video and photo output, set mirror,video start do capture
1891 * SubFunction: NA
1892 * FunctionPoints: NA
1893 * EnvConditions: NA
1894 * CaseDescription: Test add preview video and photo output, video start do capture
1895 */
1896 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_059, TestSize.Level0)
1897 {
1898 Camera_CaptureSession* captureSession = nullptr;
1899 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
1900 EXPECT_EQ(ret, CAMERA_OK);
1901 EXPECT_NE(captureSession, nullptr);
1902 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1903 EXPECT_EQ(ret, CAMERA_OK);
1904 Camera_Input *cameraInput = nullptr;
1905 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1906 EXPECT_EQ(ret, CAMERA_OK);
1907 ret = OH_CameraInput_Open(cameraInput);
1908 EXPECT_EQ(ret, CAMERA_OK);
1909 EXPECT_NE(&cameraInput, nullptr);
1910 ret = OH_CaptureSession_BeginConfig(captureSession);
1911 EXPECT_EQ(ret, 0);
1912 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1913 EXPECT_EQ(ret, 0);
1914 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1915 EXPECT_NE(videoOutput, nullptr);
1916 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
1917 EXPECT_NE(photoOutput, nullptr);
1918 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1919 EXPECT_NE(previewOutput, nullptr);
1920 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
1921 EXPECT_EQ(ret, 0);
1922 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1923 EXPECT_EQ(ret, 0);
1924 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
1925 EXPECT_EQ(ret, 0);
1926 ret = OH_CaptureSession_CommitConfig(captureSession);
1927 EXPECT_EQ(ret, 0);
1928 ret = OH_VideoOutput_Start(videoOutput);
1929 EXPECT_EQ(ret, 0);
1930 Camera_PhotoCaptureSetting capSettings;
1931 capSettings.mirror = true;
1932 ret = OH_PhotoOutput_Capture_WithCaptureSetting(photoOutput, capSettings);
1933 EXPECT_EQ(ret, 0);
1934 ret = OH_VideoOutput_Stop(videoOutput);
1935 EXPECT_EQ(ret, 0);
1936 ret = OH_VideoOutput_Release(videoOutput);
1937 EXPECT_EQ(ret, 0);
1938 ret = OH_PhotoOutput_Release(photoOutput);
1939 EXPECT_EQ(ret, CAMERA_OK);
1940 ret = OH_CameraInput_Release(cameraInput);
1941 EXPECT_EQ(ret, 0);
1942 ret = OH_CaptureSession_Release(captureSession);
1943 EXPECT_EQ(ret, 0);
1944 ReleaseImageReceiver();
1945 }
1946
1947 /*
1948 * Feature: Framework
1949 * Function: Test open flash preview capture video callback
1950 * SubFunction: NA
1951 * FunctionPoints: NA
1952 * EnvConditions: NA
1953 * CaseDescription: Test open flash preview capture video callback
1954 */
1955 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_061, TestSize.Level0)
1956 {
1957 Camera_ErrorCode ret = CAMERA_OK;
1958 Camera_CaptureSession* captureSession = nullptr;
1959 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
1960 EXPECT_NE(captureSession, nullptr);
1961 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
1962 EXPECT_EQ(ret, CAMERA_OK);
1963
1964 Camera_Input *cameraInput = nullptr;
1965 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
1966 EXPECT_EQ(ret, CAMERA_OK);
1967
1968 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
1969 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
1970
1971 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_OPEN);
1972 bool isSupported = false;
1973 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
1974 EXPECT_EQ(ret, 0);
1975
1976 if (isSupported) {
1977 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
1978 }
1979 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
1980 EXPECT_EQ(ret, 0);
1981 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
1982 EXPECT_NE(previewOutput, nullptr);
1983 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
1984 EXPECT_EQ(ret, 0);
1985 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
1986 EXPECT_NE(PhotoOutput, nullptr);
1987
1988 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
1989 EXPECT_EQ(ret, 0);
1990 Camera_VideoOutput* videoOutput = CreateVideoOutput();
1991 EXPECT_NE(videoOutput, nullptr);
1992 VideoOutput_Callbacks setVideoResultCallback = {
1993 .onFrameStart = &CameraVideoOutptOnFrameStartCb,
1994 .onFrameEnd = &CameraVideoOutptOnFrameEndCb,
1995 .onError = &CameraVideoOutptOnErrorCb
1996 };
1997 ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback);
1998 EXPECT_EQ(ret, CAMERA_OK);
1999 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0);
2000 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2001 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2002 EXPECT_EQ(OH_VideoOutput_UnregisterCallback(videoOutput, &setVideoResultCallback), 0);
2003
2004 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0);
2005 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2006 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2007 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2008 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2009 ReleaseImageReceiver();
2010 }
2011
2012 /*
2013 * Feature: Framework
2014 * Function: Test close flash preview capture video callback
2015 * SubFunction: NA
2016 * FunctionPoints: NA
2017 * EnvConditions: NA
2018 * CaseDescription: Test close flash preview capture video callback
2019 */
2020 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_065, TestSize.Level0)
2021 {
2022 Camera_ErrorCode ret = CAMERA_OK;
2023 Camera_CaptureSession* captureSession = nullptr;
2024 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2025 EXPECT_NE(captureSession, nullptr);
2026 Camera_Input *cameraInput = nullptr;
2027 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2028 EXPECT_EQ(ret, CAMERA_OK);
2029 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2030 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2031 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_OPEN);
2032 bool isSupported = false;
2033 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2034 EXPECT_EQ(ret, 0);
2035 if (isSupported) {
2036 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2037 }
2038 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2039 EXPECT_EQ(ret, 0);
2040 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2041 EXPECT_NE(previewOutput, nullptr);
2042
2043 PreviewOutput_Callbacks setPreviewResultCallback = {
2044 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2045 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2046 .onError = &CameraPreviewOutptOnErrorCb
2047 };
2048
2049 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2050 EXPECT_EQ(ret, CAMERA_OK);
2051 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2052 EXPECT_EQ(ret, 0);
2053 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2054 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2055 EXPECT_EQ(OH_PreviewOutput_UnregisterCallback(previewOutput, &setPreviewResultCallback), 0);
2056 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2057 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2058 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2059 }
2060
2061 /*
2062 * Feature: Framework
2063 * Function: Test close flash preview capture video callback
2064 * SubFunction: NA
2065 * FunctionPoints: NA
2066 * EnvConditions: NA
2067 * CaseDescription: Test close flash preview capture video callback
2068 */
2069 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_066, TestSize.Level0)
2070 {
2071 Camera_ErrorCode ret = CAMERA_OK;
2072 Camera_CaptureSession* captureSession = nullptr;
2073 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2074 EXPECT_NE(captureSession, nullptr);
2075 Camera_Input *cameraInput = nullptr;
2076 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2077 EXPECT_EQ(ret, CAMERA_OK);
2078 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2079 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2080 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_OPEN);
2081 bool isSupported = false;
2082 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2083 EXPECT_EQ(ret, 0);
2084 if (isSupported) {
2085 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2086 }
2087 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2088 EXPECT_EQ(ret, 0);
2089 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2090 EXPECT_NE(previewOutput, nullptr);
2091 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2092 EXPECT_EQ(ret, 0);
2093 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
2094 EXPECT_NE(PhotoOutput, nullptr);
2095 PhotoOutput_Callbacks setPhotoOutputResultCallback = {
2096 .onFrameStart = &CameraPhotoOutptOnFrameStartCb,
2097 .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb,
2098 .onFrameEnd = &CameraPhotoOutptOnFrameEndCb,
2099 .onError = &CameraPhotoOutptOnErrorCb
2100 };
2101 ret = OH_PhotoOutput_RegisterCallback(PhotoOutput, &setPhotoOutputResultCallback);
2102 EXPECT_EQ(ret, CAMERA_OK);
2103 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
2104 EXPECT_EQ(ret, 0);
2105 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2106 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2107 EXPECT_EQ(OH_PhotoOutput_Capture(PhotoOutput), 0);
2108 EXPECT_EQ(OH_PhotoOutput_UnregisterCallback(PhotoOutput, &setPhotoOutputResultCallback), 0);
2109 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2110 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2111 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2112 ReleaseImageReceiver();
2113 }
2114
2115 /*
2116 * Feature: Framework
2117 * Function: Test close flash preview capture video callback
2118 * SubFunction: NA
2119 * FunctionPoints: NA
2120 * EnvConditions: NA
2121 * CaseDescription: Test close flash preview capture video callback
2122 */
2123 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_062, TestSize.Level0)
2124 {
2125 Camera_ErrorCode ret = CAMERA_OK;
2126 Camera_CaptureSession* captureSession = nullptr;
2127 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2128 EXPECT_NE(captureSession, nullptr);
2129 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
2130 EXPECT_EQ(ret, CAMERA_OK);
2131 Camera_Input *cameraInput = nullptr;
2132 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2133 EXPECT_EQ(ret, CAMERA_OK);
2134 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2135 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2136 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_CLOSE);
2137 bool isSupported = false;
2138 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2139 EXPECT_EQ(ret, 0);
2140 if (isSupported) {
2141 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2142 }
2143 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2144 EXPECT_EQ(ret, 0);
2145 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2146 EXPECT_NE(previewOutput, nullptr);
2147 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2148 EXPECT_EQ(ret, 0);
2149 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
2150 EXPECT_NE(PhotoOutput, nullptr);
2151
2152 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
2153 EXPECT_EQ(ret, 0);
2154 Camera_VideoOutput* videoOutput = CreateVideoOutput();
2155 EXPECT_NE(videoOutput, nullptr);
2156 VideoOutput_Callbacks setVideoResultCallback = {
2157 .onFrameStart = &CameraVideoOutptOnFrameStartCb,
2158 .onFrameEnd = &CameraVideoOutptOnFrameEndCb,
2159 .onError = &CameraVideoOutptOnErrorCb
2160 };
2161 ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback);
2162 EXPECT_EQ(ret, CAMERA_OK);
2163 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0);
2164 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2165 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2166 EXPECT_EQ(OH_VideoOutput_UnregisterCallback(videoOutput, &setVideoResultCallback), 0);
2167
2168 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0);
2169 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2170 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2171 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2172 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2173 ReleaseImageReceiver();
2174 }
2175
2176 /*
2177 * Feature: Framework
2178 * Function: Test close flash preview capture video callback
2179 * SubFunction: NA
2180 * FunctionPoints: NA
2181 * EnvConditions: NA
2182 * CaseDescription: Test close flash preview capture video callback
2183 */
2184 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_063, TestSize.Level0)
2185 {
2186 Camera_ErrorCode ret = CAMERA_OK;
2187 Camera_CaptureSession* captureSession = nullptr;
2188 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2189 EXPECT_NE(captureSession, nullptr);
2190 Camera_Input *cameraInput = nullptr;
2191 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2192 EXPECT_EQ(ret, CAMERA_OK);
2193 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2194 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2195 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_CLOSE);
2196 bool isSupported = false;
2197 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2198 EXPECT_EQ(ret, 0);
2199 if (isSupported) {
2200 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2201 }
2202 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2203 EXPECT_EQ(ret, 0);
2204 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2205 EXPECT_NE(previewOutput, nullptr);
2206
2207 PreviewOutput_Callbacks setPreviewResultCallback = {
2208 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2209 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2210 .onError = &CameraPreviewOutptOnErrorCb
2211 };
2212
2213 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2214 EXPECT_EQ(ret, CAMERA_OK);
2215 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2216 EXPECT_EQ(ret, 0);
2217 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2218 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2219 EXPECT_EQ(OH_PreviewOutput_UnregisterCallback(previewOutput, &setPreviewResultCallback), 0);
2220 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2221 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2222 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2223 }
2224
2225 /*
2226 * Feature: Framework
2227 * Function: Test close flash preview capture video callback
2228 * SubFunction: NA
2229 * FunctionPoints: NA
2230 * EnvConditions: NA
2231 * CaseDescription: Test close flash preview capture video callback
2232 */
2233 HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_064, TestSize.Level0)
2234 {
2235 Camera_ErrorCode ret = CAMERA_OK;
2236 Camera_CaptureSession* captureSession = nullptr;
2237 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2238 EXPECT_NE(captureSession, nullptr);
2239 Camera_Input *cameraInput = nullptr;
2240 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2241 EXPECT_EQ(ret, CAMERA_OK);
2242 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
2243 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2244 Camera_FlashMode flash =static_cast<Camera_FlashMode>(FLASH_MODE_CLOSE);
2245 bool isSupported = false;
2246 ret = OH_CaptureSession_IsFlashModeSupported(captureSession, flash, &isSupported);
2247 EXPECT_EQ(ret, 0);
2248 if (isSupported) {
2249 EXPECT_EQ(OH_CaptureSession_SetFlashMode(captureSession, flash), 0);
2250 }
2251 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2252 EXPECT_EQ(ret, 0);
2253 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2254 EXPECT_NE(previewOutput, nullptr);
2255 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2256 EXPECT_EQ(ret, 0);
2257 Camera_PhotoOutput* PhotoOutput = CreatePhotoOutput();
2258 EXPECT_NE(PhotoOutput, nullptr);
2259 PhotoOutput_Callbacks setPhotoOutputResultCallback = {
2260 .onFrameStart = &CameraPhotoOutptOnFrameStartCb,
2261 .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb,
2262 .onFrameEnd = &CameraPhotoOutptOnFrameEndCb,
2263 .onError = &CameraPhotoOutptOnErrorCb
2264 };
2265 ret = OH_PhotoOutput_RegisterCallback(PhotoOutput, &setPhotoOutputResultCallback);
2266 EXPECT_EQ(ret, CAMERA_OK);
2267 ret = OH_CaptureSession_AddPhotoOutput(captureSession, PhotoOutput);
2268 EXPECT_EQ(ret, 0);
2269 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2270 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), 0);
2271 EXPECT_EQ(OH_PhotoOutput_Capture(PhotoOutput), 0);
2272 EXPECT_EQ(OH_PhotoOutput_UnregisterCallback(PhotoOutput, &setPhotoOutputResultCallback), 0);
2273 EXPECT_EQ(OH_PhotoOutput_Release(PhotoOutput), 0);
2274 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2275 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2276 ReleaseImageReceiver();
2277 }
2278
2279 /*
2280 * Feature: Framework
2281 * Function: Test cameramanager create input with position and type
2282 * SubFunction: NA
2283 * FunctionPoints: NA
2284 * EnvConditions: NA
2285 * CaseDescription: Test cameramanager create input with position and type
2286 */
2287 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_001, TestSize.Level0)
2288 {
2289 Camera_ErrorCode ret = CAMERA_OK;
2290 Camera_Input *camInputPosAndType = nullptr;
2291 Camera_Position cameraPosition = Camera_Position::CAMERA_POSITION_BACK;
2292 Camera_Type cameraType = Camera_Type::CAMERA_TYPE_DEFAULT;
2293 ret = OH_CameraManager_CreateCameraInput_WithPositionAndType(cameraManager,
2294 cameraPosition, cameraType, &camInputPosAndType);
2295 EXPECT_EQ(ret, CAMERA_OK);
2296 EXPECT_NE(&camInputPosAndType, nullptr);
2297
2298 cameraPosition = Camera_Position::CAMERA_POSITION_FRONT;
2299 ret = OH_CameraManager_CreateCameraInput_WithPositionAndType(cameraManager,
2300 cameraPosition, cameraType, &camInputPosAndType);
2301 EXPECT_EQ(ret, CAMERA_OK);
2302 }
2303
2304 /*
2305 * Feature: Framework
2306 * Function: Test cameramanager delete supported cameras, output capability and manager
2307 * SubFunction: NA
2308 * FunctionPoints: NA
2309 * EnvConditions: NA
2310 * CaseDescription: Test cameramanager delete supported cameras, output capability and manager
2311 */
2312 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_002, TestSize.Level0)
2313 {
2314 Camera_ErrorCode ret = CAMERA_OK;
2315 Camera_CaptureSession* captureSession = nullptr;
2316 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2317 EXPECT_EQ(ret, CAMERA_OK);
2318 EXPECT_NE(captureSession, nullptr);
2319 Camera_OutputCapability *OutputCapability = nullptr;
2320
2321 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
2322 EXPECT_EQ(ret, CAMERA_OK);
2323
2324 ret = OH_CameraManager_DeleteSupportedCameras(cameraManager, cameraDevice, cameraDeviceSize);
2325 EXPECT_EQ(ret, 0);
2326
2327 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2328 EXPECT_EQ(ret, 0);
2329
2330 ret = OH_Camera_DeleteCameraManager(cameraManager);
2331 EXPECT_EQ(ret, 0);
2332 }
2333
2334 /*
2335 * Feature: Framework
2336 * Function: Test cameramanager delete supported without profiles
2337 * SubFunction: NA
2338 * FunctionPoints: NA
2339 * EnvConditions: NA
2340 * CaseDescription: Test cameramanager delete supported without profiles
2341 */
2342 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_004, TestSize.Level0)
2343 {
2344 Camera_ErrorCode ret = CAMERA_OK;
2345 Camera_CaptureSession* captureSession = nullptr;
2346 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2347 EXPECT_EQ(ret, CAMERA_OK);
2348 EXPECT_NE(captureSession, nullptr);
2349 Camera_OutputCapability *OutputCapability = nullptr;
2350
2351 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
2352 EXPECT_EQ(ret, CAMERA_OK);
2353
2354 OutputCapability->previewProfiles = nullptr;
2355 OutputCapability->photoProfiles = nullptr;
2356 OutputCapability->videoProfiles = nullptr;
2357 OutputCapability->supportedMetadataObjectTypes = nullptr;
2358 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2359 EXPECT_EQ(ret, 0);
2360
2361 ret = OH_Camera_DeleteCameraManager(cameraManager);
2362 EXPECT_EQ(ret, 0);
2363 }
2364
2365 /*
2366 * Feature: Framework
2367 * Function: Test cameramanager delete supported without cameraDevice and cameraOutputCapability
2368 * SubFunction: NA
2369 * FunctionPoints: NA
2370 * EnvConditions: NA
2371 * CaseDescription: Test cameramanager delete supported without cameraDevice and cameraOutputCapability
2372 */
2373 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_005, TestSize.Level0)
2374 {
2375 Camera_ErrorCode ret = CAMERA_OK;
2376 Camera_CaptureSession* captureSession = nullptr;
2377 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2378 EXPECT_EQ(ret, CAMERA_OK);
2379 EXPECT_NE(captureSession, nullptr);
2380 Camera_OutputCapability *OutputCapability = nullptr;
2381
2382 ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability);
2383 EXPECT_EQ(ret, CAMERA_OK);
2384
2385 cameraDevice = nullptr;
2386 ret = OH_CameraManager_DeleteSupportedCameras(cameraManager, cameraDevice, cameraDeviceSize);
2387 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2388
2389 OutputCapability = nullptr;
2390 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2391 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2392
2393 ret = OH_Camera_DeleteCameraManager(cameraManager);
2394 EXPECT_EQ(ret, 0);
2395 }
2396
2397 /*
2398 * Feature: Framework
2399 * Function: Test capture session about zoom and mode with not commit
2400 * SubFunction: NA
2401 * FunctionPoints: NA
2402 * EnvConditions: NA
2403 * CaseDescription: Test capture session about zoom and mode with not commit
2404 */
2405 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_008, TestSize.Level0)
2406 {
2407 Camera_ErrorCode ret = CAMERA_OK;
2408 Camera_CaptureSession* captureSession = nullptr;
2409 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2410 EXPECT_EQ(ret, CAMERA_OK);
2411 EXPECT_NE(captureSession, nullptr);
2412
2413 float minZoom = 0.0f, maxZoom = 0.0f;
2414 ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
2415 EXPECT_EQ(ret, 0);
2416
2417 float zoom = 0.0f;
2418 ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom);
2419 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2420
2421 Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_AUTO;
2422 bool isSupportedFocusMode = true;
2423 ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode);
2424 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2425
2426 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
2427 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
2428 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2429
2430 Camera_Point FocusPointSet = {1.0, 2.0};
2431 ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet);
2432
2433 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
2434 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
2435 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2436
2437 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2438 bool isSupportedExposureMode = true;
2439 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode);
2440 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2441
2442 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2443 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
2444 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2445
2446 Camera_Point exposurePointSet = {1.0, 2.0};
2447 ret = OH_CaptureSession_SetMeteringPoint(captureSession, exposurePointSet);
2448 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2449
2450 float minExposureBias = 0.0f;
2451 ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias);
2452 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2453 }
2454
2455 /*
2456 * Feature: Framework
2457 * Function: Test capture session about zoom and mode with commit
2458 * SubFunction: NA
2459 * FunctionPoints: NA
2460 * EnvConditions: NA
2461 * CaseDescription: Test capture session about zoom and mode with commit
2462 */
2463 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_009, TestSize.Level0)
2464 {
2465 Camera_PhotoOutput *photoOutput = CreatePhotoOutput();
2466 EXPECT_NE(photoOutput, nullptr);
2467 Camera_CaptureSession* captureSession = nullptr;
2468 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2469 EXPECT_EQ(ret, CAMERA_OK);
2470 EXPECT_NE(captureSession, nullptr);
2471 Camera_Input *cameraInput = nullptr;
2472 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2473 EXPECT_EQ(ret, CAMERA_OK);
2474 EXPECT_NE(&cameraInput, nullptr);
2475
2476 ret = OH_CameraInput_Open(cameraInput);
2477 EXPECT_EQ(ret, CAMERA_OK);
2478 ret = OH_CaptureSession_BeginConfig(captureSession);
2479 EXPECT_EQ(ret, 0);
2480 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2481 EXPECT_EQ(ret, 0);
2482 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
2483 EXPECT_EQ(ret, 0);
2484
2485 ret = OH_CaptureSession_CommitConfig(captureSession);
2486 EXPECT_EQ(ret, 0);
2487
2488 ret = OH_CaptureSession_Start(captureSession);
2489 EXPECT_EQ(ret, 0);
2490
2491 float minZoom = 0.0f, maxZoom = 0.0f;
2492 ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
2493 EXPECT_EQ(ret, 0);
2494
2495 float zoom = 0.0f;
2496 ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom);
2497 EXPECT_EQ(ret, 0);
2498
2499 Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_MANUAL;
2500 bool isSupportedFocusMode = true;
2501 ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode);
2502 EXPECT_EQ(ret, 0);
2503
2504 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
2505 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
2506 EXPECT_EQ(ret, 0);
2507
2508 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
2509 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
2510 EXPECT_EQ(ret, 0);
2511
2512 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2513 bool isSupportedExposureMode = true;
2514 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode);
2515 EXPECT_EQ(ret, 0);
2516
2517 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2518 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
2519 EXPECT_EQ(ret, 0);
2520
2521 ret = OH_CaptureSession_Release(captureSession);
2522 EXPECT_EQ(ret, 0);
2523 ReleaseImageReceiver();
2524 }
2525
2526 /*
2527 * Feature: Framework
2528 * Function: Test capture session about zoom and mode with not commit
2529 * SubFunction: NA
2530 * FunctionPoints: NA
2531 * EnvConditions: NA
2532 * CaseDescription: Test capture session about zoom and mode with not commit
2533 */
2534 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_010, TestSize.Level0)
2535 {
2536 Camera_ErrorCode ret = CAMERA_OK;
2537 Camera_CaptureSession* captureSession = nullptr;
2538 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2539 EXPECT_EQ(ret, CAMERA_OK);
2540 EXPECT_NE(captureSession, nullptr);
2541
2542 float minZoom = 0.0f, maxZoom = 0.0f;
2543 ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom);
2544 EXPECT_EQ(ret, 0);
2545
2546 float zoom = 0.0f;
2547 ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom);
2548 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2549
2550 Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_AUTO;
2551 bool isSupportedFocusMode = true;
2552 ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode);
2553 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2554
2555 Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO;
2556 ret = OH_CaptureSession_SetFocusMode(captureSession, focus);
2557 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2558
2559 Camera_Point FocusPointSet = {1.0, 2.0};
2560 ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet);
2561
2562 Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN;
2563 ret = OH_CaptureSession_SetFlashMode(captureSession, flash);
2564 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2565
2566 Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2567 bool isSupportedExposureMode = true;
2568 ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode);
2569 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2570
2571 Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO;
2572 ret = OH_CaptureSession_SetExposureMode(captureSession, exposure);
2573 EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR);
2574 }
2575
2576 /*
2577 * Feature: Framework
2578 * Function: Test capture session remove input
2579 * SubFunction: NA
2580 * FunctionPoints: NA
2581 * EnvConditions: NA
2582 * CaseDescription: Test capture session remove input
2583 */
2584 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_011, TestSize.Level0)
2585 {
2586 Camera_ErrorCode ret = CAMERA_OK;
2587 Camera_Input *cameraInput = nullptr;
2588 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2589 EXPECT_EQ(ret, CAMERA_OK);
2590 ret = OH_CameraInput_Open(cameraInput);
2591 EXPECT_EQ(ret, CAMERA_OK);
2592 Camera_CaptureSession* captureSession = nullptr;
2593 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2594 EXPECT_EQ(ret, CAMERA_OK);
2595 EXPECT_NE(captureSession, nullptr);
2596 ret = OH_CaptureSession_BeginConfig(captureSession);
2597 EXPECT_EQ(ret, 0);
2598 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2599 EXPECT_EQ(ret, 0);
2600 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2601 EXPECT_NE(previewOutput, nullptr);
2602 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2603 EXPECT_EQ(ret, 0);
2604 ret = OH_CaptureSession_CommitConfig(captureSession);
2605 EXPECT_EQ(ret, 0);
2606 ret = OH_CaptureSession_BeginConfig(captureSession);
2607 EXPECT_EQ(ret, 0);
2608 ret = OH_CaptureSession_RemoveInput(captureSession, cameraInput);
2609 EXPECT_EQ(ret, 0);
2610 ret = OH_CameraInput_Release(cameraInput);
2611 EXPECT_EQ(ret, 0);
2612 cameraInput = nullptr;
2613 }
2614
2615 /*
2616 * Feature: Framework
2617 * Function: Test preview capture photo callback
2618 * SubFunction: NA
2619 * FunctionPoints: NA
2620 * EnvConditions: NA
2621 * CaseDescription: Test preview capture photo callback
2622 */
2623 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_012, TestSize.Level0)
2624 {
2625 CameraManager_Callbacks setCameraManagerResultCallback = {
2626 .onCameraStatus = &CameraManagerOnCameraStatusCb,
2627 };
2628 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
2629 EXPECT_EQ(ret, CAMERA_OK);
2630
2631 ret = CAMERA_OK;
2632 Camera_CaptureSession* captureSession = nullptr;
2633 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2634 EXPECT_NE(captureSession, nullptr);
2635 CaptureSession_Callbacks setCaptureSessionResultCallback = {
2636 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
2637 .onError = &CameraCaptureSessionOnErrorCb
2638 };
2639 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
2640 EXPECT_EQ(ret, CAMERA_OK);
2641
2642 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2643 EXPECT_NE(previewOutput, nullptr);
2644 PreviewOutput_Callbacks setPreviewResultCallback = {
2645 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2646 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2647 .onError = &CameraPreviewOutptOnErrorCb
2648 };
2649 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2650 EXPECT_EQ(ret, CAMERA_OK);
2651
2652 Camera_Input *cameraInput = nullptr;
2653 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2654 EXPECT_EQ(ret, CAMERA_OK);
2655 CameraInput_Callbacks cameraInputCallbacks = {
2656 .onError = OnCameraInputError
2657 };
2658 ret = OH_CameraInput_RegisterCallback(cameraInput, &cameraInputCallbacks);
2659 EXPECT_EQ(ret, CAMERA_OK);
2660 ret = OH_CameraInput_Open(cameraInput);
2661 EXPECT_EQ(ret, CAMERA_OK);
2662
2663 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2664 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
2665 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), 0);
2666 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2667 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2668
2669 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), 0);
2670 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2671 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
2672 EXPECT_NE(photoOutput, nullptr);
2673 PhotoOutput_Callbacks setPhotoOutputResultCallback = {
2674 .onFrameStart = &CameraPhotoOutptOnFrameStartCb,
2675 .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb,
2676 .onFrameEnd = &CameraPhotoOutptOnFrameEndCb,
2677 .onError = &CameraPhotoOutptOnErrorCb
2678 };
2679 ret = OH_PhotoOutput_RegisterCallback(photoOutput, &setPhotoOutputResultCallback);
2680 EXPECT_EQ(ret, CAMERA_OK);
2681
2682 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), 0);
2683 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2684 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2685 EXPECT_EQ(OH_PhotoOutput_Capture(photoOutput), 0);
2686 sleep(2);
2687
2688 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), 0);
2689 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), 0);
2690 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2691 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2692 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2693 ReleaseImageReceiver();
2694 }
2695
2696 /*
2697 * Feature: Framework
2698 * Function: Test preview capture video callback
2699 * SubFunction: NA
2700 * FunctionPoints: NA
2701 * EnvConditions: NA
2702 * CaseDescription: Test preview capture video callback
2703 */
2704 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_013, TestSize.Level0)
2705 {
2706 CameraManager_Callbacks setCameraManagerResultCallback = {
2707 .onCameraStatus = &CameraManagerOnCameraStatusCb,
2708 };
2709 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
2710 EXPECT_EQ(ret, CAMERA_OK);
2711
2712 ret = CAMERA_OK;
2713 Camera_CaptureSession* captureSession = nullptr;
2714 EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0);
2715 EXPECT_NE(captureSession, nullptr);
2716 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
2717 EXPECT_EQ(ret, CAMERA_OK);
2718 CaptureSession_Callbacks setCaptureSessionResultCallback = {
2719 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
2720 .onError = &CameraCaptureSessionOnErrorCb
2721 };
2722 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
2723 EXPECT_EQ(ret, CAMERA_OK);
2724
2725 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2726 EXPECT_NE(previewOutput, nullptr);
2727 PreviewOutput_Callbacks setPreviewResultCallback = {
2728 .onFrameStart = &CameraPreviewOutptOnFrameStartCb,
2729 .onFrameEnd = &CameraPreviewOutptOnFrameEndCb,
2730 .onError = &CameraPreviewOutptOnErrorCb
2731 };
2732 ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback);
2733 EXPECT_EQ(ret, CAMERA_OK);
2734
2735 Camera_Input *cameraInput = nullptr;
2736 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2737 EXPECT_EQ(ret, CAMERA_OK);
2738 CameraInput_Callbacks cameraInputCallbacks = {
2739 .onError = OnCameraInputError
2740 };
2741 ret = OH_CameraInput_RegisterCallback(cameraInput, &cameraInputCallbacks);
2742 EXPECT_EQ(ret, CAMERA_OK);
2743 ret = OH_CameraInput_Open(cameraInput);
2744 EXPECT_EQ(ret, CAMERA_OK);
2745
2746 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2747 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
2748 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), 0);
2749 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2750 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2751
2752 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), 0);
2753 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0);
2754 Camera_VideoOutput* videoOutput = CreateVideoOutput();
2755 EXPECT_NE(videoOutput, nullptr);
2756 VideoOutput_Callbacks setVideoResultCallback = {
2757 .onFrameStart = &CameraVideoOutptOnFrameStartCb,
2758 .onFrameEnd = &CameraVideoOutptOnFrameEndCb,
2759 .onError = &CameraVideoOutptOnErrorCb
2760 };
2761 ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback);
2762 EXPECT_EQ(ret, CAMERA_OK);
2763
2764 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0);
2765 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0);
2766 EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0);
2767 EXPECT_EQ(OH_VideoOutput_Start(videoOutput), 0);
2768 sleep(2);
2769
2770 EXPECT_EQ(OH_VideoOutput_Stop(videoOutput), 0);
2771 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0);
2772 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0);
2773 EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0);
2774 EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0);
2775 ReleaseImageReceiver();
2776 }
2777
2778 /*
2779 * Feature: Framework
2780 * Function: Test Get supported scene modes and delete scene modes
2781 * SubFunction: NA
2782 * FunctionPoints: NA
2783 * EnvConditions: NA
2784 * CaseDescription: Test Get supported scene modes and delete scene modes
2785 */
2786 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_014, TestSize.Level0)
2787 {
2788 Camera_SceneMode* sceneModes = nullptr;
2789 uint32_t size = 0;
2790 Camera_ErrorCode ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
2791 EXPECT_EQ(ret, CAMERA_OK);
2792 ret = OH_CameraManager_GetSupportedSceneModes(nullptr, &sceneModes, &size);
2793 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2794 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, nullptr, &size);
2795 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2796 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, nullptr);
2797 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2798 if (sceneModes != nullptr) {
2799 ret = OH_CameraManager_DeleteSceneModes(cameraManager, sceneModes);
2800 EXPECT_EQ(ret, CAMERA_OK);
2801 }
2802 ret = OH_CameraManager_DeleteSceneModes(nullptr, sceneModes);
2803 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2804 ret = OH_CameraManager_DeleteSceneModes(cameraManager, nullptr);
2805 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2806 }
2807
2808 /*
2809 * Feature: Framework
2810 * Function: Test get supported output capabilities with scene mode
2811 * SubFunction: NA
2812 * FunctionPoints: NA
2813 * EnvConditions: NA
2814 * CaseDescription: Test get supported output capabilities with scene mode
2815 */
2816 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_015, TestSize.Level0)
2817 {
2818 Camera_CaptureSession* captureSession = nullptr;
2819 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2820 EXPECT_EQ(ret, CAMERA_OK);
2821 ASSERT_NE(captureSession, nullptr);
2822 Camera_OutputCapability *OutputCapability = nullptr;
2823 Camera_SceneMode mode = NORMAL_PHOTO;
2824 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(cameraManager, cameraDevice, mode,
2825 &OutputCapability);
2826 EXPECT_EQ(ret, CAMERA_OK);
2827 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(nullptr, cameraDevice, mode,
2828 &OutputCapability);
2829 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2830 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(cameraManager, nullptr, mode,
2831 &OutputCapability);
2832 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2833 ret = OH_CameraManager_GetSupportedCameraOutputCapabilityWithSceneMode(cameraManager, cameraDevice, mode, nullptr);
2834 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2835 if (OutputCapability != nullptr) {
2836 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability);
2837 EXPECT_EQ(ret, CAMERA_OK);
2838 }
2839 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(nullptr, OutputCapability);
2840 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2841 ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, nullptr);
2842 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2843 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2844 }
2845
2846 /*
2847 * Feature: Framework
2848 * Function: Test if a capture session can add a camera input
2849 * SubFunction: NA
2850 * FunctionPoints: NA
2851 * EnvConditions: NA
2852 * CaseDescription: Test if a capture session can add a camera input
2853 */
2854 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_016, TestSize.Level0)
2855 {
2856 bool isSuccess = false;
2857 Camera_CaptureSession* captureSession = nullptr;
2858 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2859 EXPECT_EQ(ret, CAMERA_OK);
2860 ASSERT_NE(captureSession, nullptr);
2861 Camera_Input *cameraInput = nullptr;
2862 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2863 EXPECT_EQ(ret, CAMERA_OK);
2864 ret = OH_CameraInput_Open(cameraInput);
2865 EXPECT_EQ(ret, CAMERA_OK);
2866
2867 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
2868 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccess);
2869 EXPECT_EQ(ret, CAMERA_OK);
2870 EXPECT_EQ(isSuccess, true);
2871 ret = OH_CaptureSession_CanAddInput(nullptr, cameraInput, &isSuccess);
2872 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2873 ret = OH_CaptureSession_CanAddInput(captureSession, nullptr, &isSuccess);
2874 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2875 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, nullptr);
2876 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2877 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
2878 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2879 ASSERT_NE(previewOutput, nullptr);
2880 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
2881 EXPECT_EQ(ret, CAMERA_OK);
2882 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2883
2884 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2885 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2886 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2887 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2888 }
2889
2890 /*
2891 * Feature: Framework
2892 * Function: Test if a capture session can add a preview output
2893 * SubFunction: NA
2894 * FunctionPoints: NA
2895 * EnvConditions: NA
2896 * CaseDescription: Test if a capture session can add a preview output
2897 */
2898 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_017, TestSize.Level0)
2899 {
2900 bool isSuccessful = false;
2901 Camera_CaptureSession* captureSession = nullptr;
2902 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2903 EXPECT_EQ(ret, CAMERA_OK);
2904 ASSERT_NE(captureSession, nullptr);
2905 Camera_Input *cameraInput = nullptr;
2906 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2907 EXPECT_EQ(ret, CAMERA_OK);
2908 ret = OH_CameraInput_Open(cameraInput);
2909 EXPECT_EQ(ret, CAMERA_OK);
2910
2911 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
2912 EXPECT_EQ(OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccessful), CAMERA_OK);
2913 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
2914 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
2915 ASSERT_NE(previewOutput, nullptr);
2916 ret = OH_CaptureSession_CanAddPreviewOutput(captureSession, previewOutput, &isSuccessful);
2917 EXPECT_EQ(ret, CAMERA_OK);
2918 EXPECT_EQ(isSuccessful, true);
2919 ret = OH_CaptureSession_CanAddPreviewOutput(nullptr, previewOutput, &isSuccessful);
2920 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2921 ret = OH_CaptureSession_CanAddPreviewOutput(captureSession, nullptr, &isSuccessful);
2922 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2923 ret = OH_CaptureSession_CanAddPreviewOutput(captureSession, previewOutput, nullptr);
2924 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2925 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
2926 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2927
2928 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2929 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2930 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2931 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2932 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
2933 }
2934
2935 /*
2936 * Feature: Framework
2937 * Function: Test if a capture session can add a photo output
2938 * SubFunction: NA
2939 * FunctionPoints: NA
2940 * EnvConditions: NA
2941 * CaseDescription: Test if a capture session can add a photo output
2942 */
2943 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_018, TestSize.Level0)
2944 {
2945 bool isSuccessful = false;
2946 Camera_CaptureSession* captureSession = nullptr;
2947 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
2948 EXPECT_EQ(ret, CAMERA_OK);
2949 ASSERT_NE(captureSession, nullptr);
2950 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
2951 EXPECT_EQ(ret, CAMERA_OK);
2952 Camera_Input *cameraInput = nullptr;
2953 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
2954 EXPECT_EQ(ret, CAMERA_OK);
2955 ASSERT_NE(&cameraInput, nullptr);
2956 ret = OH_CameraInput_Open(cameraInput);
2957 EXPECT_EQ(ret, CAMERA_OK);
2958
2959 ret = OH_CaptureSession_BeginConfig(captureSession);
2960 EXPECT_EQ(ret, CAMERA_OK);
2961 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccessful);
2962 EXPECT_EQ(ret, CAMERA_OK);
2963 EXPECT_EQ(isSuccessful, true);
2964 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
2965 EXPECT_EQ(ret, CAMERA_OK);
2966 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
2967 ASSERT_NE(photoOutput, nullptr);
2968 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
2969 EXPECT_EQ(ret, CAMERA_OK);
2970 EXPECT_EQ(isSuccessful, true);
2971 ret = OH_CaptureSession_CanAddPhotoOutput(nullptr, photoOutput, &isSuccessful);
2972 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2973 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, nullptr, &isSuccessful);
2974 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2975 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, nullptr);
2976 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
2977 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
2978 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
2979
2980 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
2981 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
2982 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
2983 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
2984 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
2985 }
2986
2987 /*
2988 * Feature: Framework
2989 * Function: Test if a capture session can add a video output
2990 * SubFunction: NA
2991 * FunctionPoints: NA
2992 * EnvConditions: NA
2993 * CaseDescription: Test if a capture session can add a video output
2994 */
2995 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_019, TestSize.Level0)
2996 {
2997 bool isSuccessful = false;
2998 Camera_CaptureSession* captureSession = nullptr;
2999 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3000 EXPECT_EQ(ret, CAMERA_OK);
3001 ASSERT_NE(captureSession, nullptr);
3002 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3003 EXPECT_EQ(ret, CAMERA_OK);
3004 Camera_Input *cameraInput = nullptr;
3005 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3006 EXPECT_EQ(ret, CAMERA_OK);
3007 ASSERT_NE(&cameraInput, nullptr);
3008 ret = OH_CameraInput_Open(cameraInput);
3009 EXPECT_EQ(ret, CAMERA_OK);
3010
3011 ret = OH_CaptureSession_BeginConfig(captureSession);
3012 EXPECT_EQ(ret, CAMERA_OK);
3013 ret = OH_CaptureSession_CanAddInput(captureSession, cameraInput, &isSuccessful);
3014 EXPECT_EQ(ret, CAMERA_OK);
3015 EXPECT_EQ(isSuccessful, true);
3016 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3017 EXPECT_EQ(ret, CAMERA_OK);
3018 Camera_VideoOutput* videoOutput = CreateVideoOutput();
3019 ASSERT_NE(videoOutput, nullptr);
3020 ret = OH_CaptureSession_CanAddVideoOutput(captureSession, videoOutput, &isSuccessful);
3021 EXPECT_EQ(ret, CAMERA_OK);
3022 EXPECT_EQ(isSuccessful, true);
3023 ret = OH_CaptureSession_CanAddVideoOutput(nullptr, videoOutput, &isSuccessful);
3024 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3025 ret = OH_CaptureSession_CanAddVideoOutput(captureSession, nullptr, &isSuccessful);
3026 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3027 ret = OH_CaptureSession_CanAddVideoOutput(captureSession, videoOutput, nullptr);
3028 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3029 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), CAMERA_OK);
3030 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3031
3032 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3033 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3034 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3035 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3036 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3037 }
3038
3039 /*
3040 * Feature: Framework
3041 * Function: Test set session mode in photo session
3042 * SubFunction: NA
3043 * FunctionPoints: NA
3044 * EnvConditions: NA
3045 * CaseDescription: Test set session mode in photo session
3046 */
3047 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_020, TestSize.Level0)
3048 {
3049 Camera_CaptureSession* captureSession = nullptr;
3050 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3051 EXPECT_EQ(ret, CAMERA_OK);
3052 ASSERT_NE(captureSession, nullptr);
3053 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3054 EXPECT_EQ(ret, CAMERA_OK);
3055 Camera_Input *cameraInput = nullptr;
3056 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3057 EXPECT_EQ(ret, CAMERA_OK);
3058 ret = OH_CameraInput_Open(cameraInput);
3059 EXPECT_EQ(ret, CAMERA_OK);
3060
3061 ret = OH_CaptureSession_BeginConfig(captureSession);
3062 EXPECT_EQ(ret, CAMERA_OK);
3063 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3064 EXPECT_EQ(ret, CAMERA_OK);
3065 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
3066 ASSERT_NE(photoOutput, nullptr);
3067 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
3068 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3069
3070 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3071 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3072 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3073 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3074 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3075 }
3076
3077 /*
3078 * Feature: Framework
3079 * Function: Test set session mode in video session
3080 * SubFunction: NA
3081 * FunctionPoints: NA
3082 * EnvConditions: NA
3083 * CaseDescription: Test set session mode in video session
3084 */
3085 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_021, TestSize.Level0)
3086 {
3087 Camera_CaptureSession* captureSession = nullptr;
3088 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3089 EXPECT_EQ(ret, CAMERA_OK);
3090 ASSERT_NE(captureSession, nullptr);
3091 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3092 EXPECT_EQ(ret, CAMERA_OK);
3093 Camera_Input *cameraInput = nullptr;
3094 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3095 EXPECT_EQ(ret, CAMERA_OK);
3096 ret = OH_CameraInput_Open(cameraInput);
3097 EXPECT_EQ(ret, CAMERA_OK);
3098
3099 ret = OH_CaptureSession_BeginConfig(captureSession);
3100 EXPECT_EQ(ret, CAMERA_OK);
3101 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3102 EXPECT_EQ(ret, CAMERA_OK);
3103 Camera_VideoOutput* videoOutput = CreateVideoOutput();
3104 ASSERT_NE(videoOutput, nullptr);
3105 EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), CAMERA_OK);
3106 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3107
3108 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3109 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3110 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3111 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3112 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3113 }
3114
3115 /*
3116 * Feature: Framework
3117 * Function: Test set session mode in secure session
3118 * SubFunction: NA
3119 * FunctionPoints: NA
3120 * EnvConditions: NA
3121 * CaseDescription: Test set session mode in secure session
3122 */
3123 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_022, TestSize.Level0)
3124 {
3125 Camera_CaptureSession* captureSession = nullptr;
3126 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3127 EXPECT_EQ(ret, CAMERA_OK);
3128 ASSERT_NE(captureSession, nullptr);
3129 ret = OH_CaptureSession_SetSessionMode(captureSession, SECURE_PHOTO);
3130 EXPECT_EQ(ret, CAMERA_OK);
3131 Camera_SceneMode* sceneModes = nullptr;
3132 uint32_t size = 0;
3133 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
3134 EXPECT_EQ(ret, CAMERA_OK);
3135 Camera_Input *cameraInput = nullptr;
3136 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3137 EXPECT_EQ(ret, CAMERA_OK);
3138 ret = OH_CameraInput_Open(cameraInput);
3139 EXPECT_EQ(ret, CAMERA_OK);
3140
3141 ret = OH_CaptureSession_BeginConfig(captureSession);
3142 EXPECT_EQ(ret, CAMERA_OK);
3143 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3144 EXPECT_EQ(ret, CAMERA_OK);
3145 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3146 ASSERT_NE(previewOutput, nullptr);
3147 for (uint32_t i = 0; i < size; i++) {
3148 if (sceneModes[i] == SECURE_PHOTO) {
3149 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3150 EXPECT_EQ(OH_CaptureSession_AddSecureOutput(captureSession, previewOutput), CAMERA_OK);
3151 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3152 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3153 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3154 } else {
3155 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3156 ret = OH_CaptureSession_AddSecureOutput(captureSession, previewOutput);
3157 ret = OH_CaptureSession_CommitConfig(captureSession);
3158 ret = OH_CaptureSession_Start(captureSession);
3159 ret = OH_CaptureSession_Stop(captureSession);
3160 }
3161 }
3162 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3163 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3164 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3165 }
3166
3167 /*
3168 * Feature: Framework
3169 * Function: Test add a secure output to the capture session
3170 * SubFunction: NA
3171 * FunctionPoints: NA
3172 * EnvConditions: NA
3173 * CaseDescription: Test add a secure output to the capture session
3174 */
3175 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_023, TestSize.Level0)
3176 {
3177 Camera_CaptureSession* captureSession = nullptr;
3178 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3179 EXPECT_EQ(ret, CAMERA_OK);
3180 ASSERT_NE(captureSession, nullptr);
3181 ret = OH_CaptureSession_SetSessionMode(captureSession, SECURE_PHOTO);
3182 EXPECT_EQ(ret, CAMERA_OK);
3183
3184 Camera_SceneMode* sceneModes = nullptr;
3185 uint32_t size = 0;
3186 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
3187 EXPECT_EQ(ret, CAMERA_OK);
3188 Camera_Input *cameraInput = nullptr;
3189 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3190 EXPECT_EQ(ret, CAMERA_OK);
3191 ret = OH_CameraInput_Open(cameraInput);
3192 EXPECT_EQ(ret, CAMERA_OK);
3193
3194 ret = OH_CaptureSession_BeginConfig(captureSession);
3195 EXPECT_EQ(ret, CAMERA_OK);
3196 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3197 EXPECT_EQ(ret, CAMERA_OK);
3198 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3199 ASSERT_NE(previewOutput, nullptr);
3200 for (uint32_t i = 0; i < size; i++) {
3201 if (sceneModes[i] == SECURE_PHOTO) {
3202 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3203 EXPECT_EQ(OH_CaptureSession_AddSecureOutput(captureSession, previewOutput), CAMERA_OK);
3204 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3205 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3206 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3207 } else {
3208 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3209 ret = OH_CaptureSession_AddSecureOutput(captureSession, previewOutput);
3210 ret = OH_CaptureSession_CommitConfig(captureSession);
3211 ret = OH_CaptureSession_Start(captureSession);
3212 ret = OH_CaptureSession_Stop(captureSession);
3213 }
3214 }
3215 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3216 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3217 }
3218
3219 /*
3220 * Feature: Framework
3221 * Function: Test register capture session callback
3222 * SubFunction: NA
3223 * FunctionPoints: NA
3224 * EnvConditions: NA
3225 * CaseDescription: Test register capture session callback
3226 */
3227 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_024, TestSize.Level0)
3228 {
3229 Camera_CaptureSession* captureSession = nullptr;
3230 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3231 EXPECT_EQ(ret, CAMERA_OK);
3232 ASSERT_NE(captureSession, nullptr);
3233 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3234 EXPECT_EQ(ret, CAMERA_OK);
3235 Camera_Input *cameraInput = nullptr;
3236 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3237 EXPECT_EQ(ret, CAMERA_OK);
3238 CaptureSession_Callbacks setCaptureSessionResultCallback = {
3239 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
3240 .onError = &CameraCaptureSessionOnErrorCb
3241 };
3242 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
3243 EXPECT_EQ(ret, CAMERA_OK);
3244 ret = OH_CaptureSession_RegisterCallback(nullptr, &setCaptureSessionResultCallback);
3245 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3246 ret = OH_CaptureSession_RegisterCallback(captureSession, nullptr);
3247 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3248 ret = OH_CameraInput_Open(cameraInput);
3249 EXPECT_EQ(ret, CAMERA_OK);
3250
3251 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
3252 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3253
3254 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3255 ASSERT_NE(previewOutput, nullptr);
3256 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3257
3258 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
3259 ASSERT_NE(photoOutput, nullptr);
3260 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
3261 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3262
3263 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3264 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3265 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
3266 EXPECT_EQ(ret, CAMERA_OK);
3267 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3268 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3269 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3270 }
3271
3272 /*
3273 * Feature: Framework
3274 * Function: Test unregister capture session callback
3275 * SubFunction: NA
3276 * FunctionPoints: NA
3277 * EnvConditions: NA
3278 * CaseDescription: Test unregister capture session callback
3279 */
3280 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_025, TestSize.Level0)
3281 {
3282 Camera_CaptureSession* captureSession = nullptr;
3283 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3284 EXPECT_EQ(ret, CAMERA_OK);
3285 ASSERT_NE(captureSession, nullptr);
3286 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3287 EXPECT_EQ(ret, CAMERA_OK);
3288 Camera_Input *cameraInput = nullptr;
3289 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3290 EXPECT_EQ(ret, CAMERA_OK);
3291 CaptureSession_Callbacks setCaptureSessionResultCallback = {
3292 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
3293 .onError = &CameraCaptureSessionOnErrorCb
3294 };
3295 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
3296 EXPECT_EQ(ret, CAMERA_OK);
3297 ret = OH_CameraInput_Open(cameraInput);
3298 EXPECT_EQ(ret, CAMERA_OK);
3299
3300 EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), CAMERA_OK);
3301 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3302
3303 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3304 ASSERT_NE(previewOutput, nullptr);
3305 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3306
3307 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
3308 ASSERT_NE(photoOutput, nullptr);
3309 EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), CAMERA_OK);
3310
3311 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3312 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3313 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3314 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
3315 EXPECT_EQ(ret, CAMERA_OK);
3316 ret = OH_CaptureSession_UnregisterCallback(nullptr, &setCaptureSessionResultCallback);
3317 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3318 ret = OH_CaptureSession_UnregisterCallback(captureSession, nullptr);
3319 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3320 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3321 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3322 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3323 }
3324
3325 /*
3326 * Feature: Framework
3327 * Function: Test open secure camera
3328 * SubFunction: NA
3329 * FunctionPoints: NA
3330 * EnvConditions: NA
3331 * CaseDescription: Test open secure camera
3332 */
3333 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_026, TestSize.Level0)
3334 {
3335 uint64_t secureSeqId = 10;
3336 Camera_CaptureSession* captureSession = nullptr;
3337 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3338 EXPECT_EQ(ret, CAMERA_OK);
3339 ASSERT_NE(captureSession, nullptr);
3340 ret = OH_CaptureSession_SetSessionMode(captureSession, SECURE_PHOTO);
3341 EXPECT_EQ(ret, CAMERA_OK);
3342
3343 Camera_SceneMode* sceneModes = nullptr;
3344 uint32_t size = 0;
3345 ret = OH_CameraManager_GetSupportedSceneModes(cameraDevice, &sceneModes, &size);
3346 EXPECT_EQ(ret, CAMERA_OK);
3347 Camera_Input *cameraInput = nullptr;
3348 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3349 EXPECT_EQ(ret, CAMERA_OK);
3350 ret = OH_CameraInput_Open(cameraInput);
3351 EXPECT_EQ(ret, CAMERA_OK);
3352
3353 ret = OH_CaptureSession_BeginConfig(captureSession);
3354 EXPECT_EQ(ret, CAMERA_OK);
3355 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
3356 EXPECT_EQ(ret, CAMERA_OK);
3357 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3358 ASSERT_NE(previewOutput, nullptr);
3359 for (uint32_t i = 0; i < size; i++) {
3360 if (sceneModes[i] == SECURE_PHOTO) {
3361 ret = OH_CameraInput_OpenSecureCamera(cameraInput, &secureSeqId);
3362 EXPECT_EQ(ret, CAMERA_OK);
3363 EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), CAMERA_OK);
3364 EXPECT_EQ(OH_CaptureSession_AddSecureOutput(captureSession, previewOutput), CAMERA_OK);
3365 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3366 EXPECT_EQ(OH_CaptureSession_Start(captureSession), CAMERA_OK);
3367 EXPECT_EQ(OH_CaptureSession_Stop(captureSession), CAMERA_OK);
3368 } else {
3369 ret = OH_CameraInput_OpenSecureCamera(cameraInput, &secureSeqId);
3370 ret = OH_CameraInput_OpenSecureCamera(nullptr, &secureSeqId);
3371 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3372 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3373 ret = OH_CaptureSession_AddSecureOutput(captureSession, previewOutput);
3374 ret = OH_CaptureSession_CommitConfig(captureSession);
3375 ret = OH_CaptureSession_Start(captureSession);
3376 ret = OH_CaptureSession_Stop(captureSession);
3377 }
3378 }
3379 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3380 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3381 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3382 }
3383
3384
3385 /*
3386 * Feature: Framework
3387 * Function: Test create preview output used in preconfig
3388 * SubFunction: NA
3389 * FunctionPoints: NA
3390 * EnvConditions: NA
3391 * CaseDescription: Test create preview output used in preconfig
3392 */
3393 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_027, TestSize.Level0)
3394 {
3395 sptr<IConsumerSurface> previewSurface = IConsumerSurface::Create();
3396 sptr<IBufferProducer> previewProducer = previewSurface->GetProducer();
3397 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(previewProducer);
3398 int64_t surfaceIdInt = previewProducer->GetUniqueId();
3399 string surfaceIdStr = std::to_string(surfaceIdInt);
3400 const char *surfaceId = nullptr;
3401 surfaceId = surfaceIdStr.c_str();
3402 SurfaceUtils::GetInstance()->Add(surfaceIdInt, pSurface);
3403 ASSERT_NE(surfaceId, nullptr);
3404
3405 Camera_CaptureSession* captureSession = nullptr;
3406 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3407 EXPECT_EQ(ret, CAMERA_OK);
3408 ASSERT_NE(captureSession, nullptr);
3409 bool canPreconfig = false;
3410 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3411 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3412 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3413 EXPECT_EQ(ret, CAMERA_OK);
3414 if (canPreconfig == true) {
3415 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3416 EXPECT_EQ(ret, CAMERA_OK);
3417 Camera_Input *cameraInput = nullptr;
3418 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3419 EXPECT_EQ(ret, CAMERA_OK);
3420 ASSERT_NE(&cameraInput, nullptr);
3421 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3422 ret = OH_CaptureSession_BeginConfig(captureSession);
3423 EXPECT_EQ(ret, CAMERA_OK);
3424 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
3425 Camera_PreviewOutput* previewOutput = nullptr;
3426 ret = OH_CameraManager_CreatePreviewOutputUsedInPreconfig(cameraManager, surfaceId, &previewOutput);
3427 EXPECT_EQ(ret, CAMERA_OK);
3428 ASSERT_NE(previewOutput, nullptr);
3429 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3430 EXPECT_EQ(ret, CAMERA_OK);
3431 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3432 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), CAMERA_OK);
3433 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), CAMERA_OK);
3434 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3435 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3436 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3437 }
3438 }
3439
3440 /*
3441 * Feature: Framework
3442 * Function: Test create photo output used in preconfig
3443 * SubFunction: NA
3444 * FunctionPoints: NA
3445 * EnvConditions: NA
3446 * CaseDescription: Test create photo output used in preconfig
3447 */
3448 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_028, TestSize.Level0)
3449 {
3450 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3451 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3452 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3453 const char* surfaceId = nullptr;
3454 surfaceId = receiverKey.c_str();
3455 ASSERT_NE(surfaceId, nullptr);
3456
3457 Camera_CaptureSession* captureSession = nullptr;
3458 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3459 EXPECT_EQ(ret, CAMERA_OK);
3460 ASSERT_NE(captureSession, nullptr);
3461 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3462 EXPECT_EQ(ret, CAMERA_OK);
3463 bool canPreconfig = false;
3464 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3465 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3466 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3467 EXPECT_EQ(ret, CAMERA_OK);
3468 if (canPreconfig == true) {
3469 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3470 EXPECT_EQ(ret, CAMERA_OK);
3471 Camera_Input *cameraInput = nullptr;
3472 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3473 EXPECT_EQ(ret, CAMERA_OK);
3474 ASSERT_NE(&cameraInput, nullptr);
3475 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3476 ret = OH_CaptureSession_BeginConfig(captureSession);
3477 EXPECT_EQ(ret, CAMERA_OK);
3478 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3479 Camera_PhotoOutput *photoOutput = nullptr;
3480 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3481 EXPECT_EQ(ret, CAMERA_OK);
3482 ASSERT_NE(photoOutput, nullptr);
3483 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3484 EXPECT_EQ(ret, CAMERA_OK);
3485 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3486 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3487 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3488 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3489 }
3490 }
3491
3492 /*
3493 * Feature: Framework
3494 * Function: Test create video output used in preconfig
3495 * SubFunction: NA
3496 * FunctionPoints: NA
3497 * EnvConditions: NA
3498 * CaseDescription: Test create video output used in preconfig
3499 */
3500 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_029, TestSize.Level0)
3501 {
3502 sptr<IConsumerSurface> videoSurface = IConsumerSurface::Create();
3503 sptr<IBufferProducer> videoProducer = videoSurface->GetProducer();
3504 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(videoProducer);
3505 int64_t surfaceIdInt = videoProducer->GetUniqueId();
3506 string surfaceIdStr = std::to_string(surfaceIdInt);
3507 const char *surfaceId = nullptr;
3508 surfaceId = surfaceIdStr.c_str();
3509 SurfaceUtils::GetInstance()->Add(surfaceIdInt, pSurface);
3510 ASSERT_NE(surfaceId, nullptr);
3511
3512 Camera_CaptureSession* captureSession = nullptr;
3513 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3514 EXPECT_EQ(ret, CAMERA_OK);
3515 ASSERT_NE(captureSession, nullptr);
3516 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3517 EXPECT_EQ(ret, CAMERA_OK);
3518
3519 bool canPreconfig = false;
3520 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3521 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3522 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3523 EXPECT_EQ(ret, CAMERA_OK);
3524 if (canPreconfig == true) {
3525 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3526 EXPECT_EQ(ret, CAMERA_OK);
3527 Camera_Input *cameraInput = nullptr;
3528 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3529 EXPECT_EQ(ret, CAMERA_OK);
3530 ASSERT_NE(&cameraInput, nullptr);
3531 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3532 ret = OH_CaptureSession_BeginConfig(captureSession);
3533 EXPECT_EQ(ret, CAMERA_OK);
3534 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3535 Camera_VideoOutput *videoOutput = nullptr;
3536 ret = OH_CameraManager_CreateVideoOutputUsedInPreconfig(cameraManager, surfaceId, &videoOutput);
3537 EXPECT_EQ(ret, CAMERA_OK);
3538 ASSERT_NE(videoOutput, nullptr);
3539 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
3540 EXPECT_EQ(ret, CAMERA_OK);
3541 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3542 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3543 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3544 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3545 }
3546 }
3547
3548 /*
3549 * Feature: Framework
3550 * Function: Test can preconfig or not
3551 * SubFunction: NA
3552 * FunctionPoints: NA
3553 * EnvConditions: NA
3554 * CaseDescription: Test can preconfig or not
3555 */
3556 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_030, TestSize.Level0)
3557 {
3558 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3559 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3560 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3561 const char* surfaceId = nullptr;
3562 surfaceId = receiverKey.c_str();
3563 ASSERT_NE(surfaceId, nullptr);
3564
3565 Camera_CaptureSession* captureSession = nullptr;
3566 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3567 EXPECT_EQ(ret, CAMERA_OK);
3568 ASSERT_NE(captureSession, nullptr);
3569 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3570 EXPECT_EQ(ret, CAMERA_OK);
3571
3572 bool canPreconfig = false;
3573 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3574 ret = OH_CaptureSession_CanPreconfig(nullptr, preconfigType, &canPreconfig);
3575 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3576 ret = OH_CaptureSession_CanPreconfig(captureSession, preconfigType, nullptr);
3577 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3578 ret = OH_CaptureSession_CanPreconfig(captureSession, preconfigType, &canPreconfig);
3579 EXPECT_EQ(ret, CAMERA_OK);
3580 if (canPreconfig == true) {
3581 ret = OH_CaptureSession_Preconfig(captureSession, preconfigType);
3582 EXPECT_EQ(ret, CAMERA_OK);
3583 Camera_Input *cameraInput = nullptr;
3584 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3585 EXPECT_EQ(ret, CAMERA_OK);
3586 ASSERT_NE(&cameraInput, nullptr);
3587 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3588 ret = OH_CaptureSession_BeginConfig(captureSession);
3589 EXPECT_EQ(ret, CAMERA_OK);
3590 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3591 Camera_PhotoOutput *photoOutput = nullptr;
3592 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3593 EXPECT_EQ(ret, CAMERA_OK);
3594 ASSERT_NE(photoOutput, nullptr);
3595 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3596 EXPECT_EQ(ret, CAMERA_OK);
3597 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3598 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3599 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3600 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3601 }
3602 }
3603
3604 /*
3605 * Feature: Framework
3606 * Function: Test can preconfig or not with ratio
3607 * SubFunction: NA
3608 * FunctionPoints: NA
3609 * EnvConditions: NA
3610 * CaseDescription: Test can preconfig or not with ratio
3611 */
3612 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_031, TestSize.Level0)
3613 {
3614 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3615 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3616 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3617 const char* surfaceId = nullptr;
3618 surfaceId = receiverKey.c_str();
3619 ASSERT_NE(surfaceId, nullptr);
3620
3621 Camera_CaptureSession* captureSession = nullptr;
3622 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3623 EXPECT_EQ(ret, CAMERA_OK);
3624 ASSERT_NE(captureSession, nullptr);
3625 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3626 EXPECT_EQ(ret, CAMERA_OK);
3627
3628 bool canPreconfig = false;
3629 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3630 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3631 ret = OH_CaptureSession_CanPreconfigWithRatio(nullptr, preconfigType, preconfigRatio, &canPreconfig);
3632 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3633 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, nullptr);
3634 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3635 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3636 EXPECT_EQ(ret, CAMERA_OK);
3637 if (canPreconfig == true) {
3638 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3639 EXPECT_EQ(ret, CAMERA_OK);
3640 Camera_Input *cameraInput = nullptr;
3641 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3642 EXPECT_EQ(ret, CAMERA_OK);
3643 ASSERT_NE(&cameraInput, nullptr);
3644 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3645 ret = OH_CaptureSession_BeginConfig(captureSession);
3646 EXPECT_EQ(ret, CAMERA_OK);
3647 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3648 Camera_PhotoOutput *photoOutput = nullptr;
3649 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3650 EXPECT_EQ(ret, CAMERA_OK);
3651 ASSERT_NE(photoOutput, nullptr);
3652 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3653 EXPECT_EQ(ret, CAMERA_OK);
3654 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3655 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3656 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3657 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3658 }
3659 }
3660
3661 /*
3662 * Feature: Framework
3663 * Function: Test preconfig
3664 * SubFunction: NA
3665 * FunctionPoints: NA
3666 * EnvConditions: NA
3667 * CaseDescription: Test preconfig
3668 */
3669 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_032, TestSize.Level0)
3670 {
3671 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3672 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3673 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3674 const char* surfaceId = nullptr;
3675 surfaceId = receiverKey.c_str();
3676 ASSERT_NE(surfaceId, nullptr);
3677
3678 Camera_CaptureSession* captureSession = nullptr;
3679 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3680 EXPECT_EQ(ret, CAMERA_OK);
3681 ASSERT_NE(captureSession, nullptr);
3682 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3683 EXPECT_EQ(ret, CAMERA_OK);
3684
3685 bool canPreconfig = false;
3686 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3687 ret = OH_CaptureSession_CanPreconfig(captureSession, preconfigType, &canPreconfig);
3688 EXPECT_EQ(ret, CAMERA_OK);
3689 if (canPreconfig == true) {
3690 ret = OH_CaptureSession_Preconfig(captureSession, preconfigType);
3691 EXPECT_EQ(ret, CAMERA_OK);
3692 Camera_Input *cameraInput = nullptr;
3693 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3694 EXPECT_EQ(ret, CAMERA_OK);
3695 ASSERT_NE(&cameraInput, nullptr);
3696 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3697 ret = OH_CaptureSession_BeginConfig(captureSession);
3698 EXPECT_EQ(ret, CAMERA_OK);
3699 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3700 Camera_PhotoOutput *photoOutput = nullptr;
3701 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3702 EXPECT_EQ(ret, CAMERA_OK);
3703 ASSERT_NE(photoOutput, nullptr);
3704 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3705 EXPECT_EQ(ret, CAMERA_OK);
3706 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3707 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3708 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3709 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3710 } else {
3711 ret = OH_CaptureSession_Preconfig(nullptr, preconfigType);
3712 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3713 }
3714 }
3715
3716 /*
3717 * Feature: Framework
3718 * Function: Test preconfig with ratio
3719 * SubFunction: NA
3720 * FunctionPoints: NA
3721 * EnvConditions: NA
3722 * CaseDescription: Test preconfig with ratio
3723 */
3724 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_033, TestSize.Level0)
3725 {
3726 imageReceiver = Media::ImageReceiver::CreateImageReceiver(RECEIVER_TEST_WIDTH, RECEIVER_TEST_HEIGHT,
3727 RECEIVER_TEST_FORMAT, RECEIVER_TEST_CAPACITY);
3728 std::string receiverKey = imageReceiver->iraContext_->GetReceiverKey();
3729 const char* surfaceId = nullptr;
3730 surfaceId = receiverKey.c_str();
3731 ASSERT_NE(surfaceId, nullptr);
3732
3733 Camera_CaptureSession* captureSession = nullptr;
3734 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3735 EXPECT_EQ(ret, CAMERA_OK);
3736 ASSERT_NE(captureSession, nullptr);
3737 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3738 EXPECT_EQ(ret, CAMERA_OK);
3739
3740 bool canPreconfig = false;
3741 Camera_PreconfigRatio preconfigRatio = PRECONFIG_RATIO_1_1;
3742 Camera_PreconfigType preconfigType = Camera_PreconfigType::PRECONFIG_720P;
3743 ret = OH_CaptureSession_CanPreconfigWithRatio(captureSession, preconfigType, preconfigRatio, &canPreconfig);
3744 EXPECT_EQ(ret, CAMERA_OK);
3745 if (canPreconfig == true) {
3746 ret = OH_CaptureSession_PreconfigWithRatio(captureSession, preconfigType, preconfigRatio);
3747 EXPECT_EQ(ret, CAMERA_OK);
3748 Camera_Input *cameraInput = nullptr;
3749 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3750 EXPECT_EQ(ret, CAMERA_OK);
3751 ASSERT_NE(&cameraInput, nullptr);
3752 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
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 = nullptr;
3757 ret = OH_CameraManager_CreatePhotoOutputUsedInPreconfig(cameraManager, surfaceId, &photoOutput);
3758 EXPECT_EQ(ret, CAMERA_OK);
3759 ASSERT_NE(photoOutput, nullptr);
3760 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
3761 EXPECT_EQ(ret, CAMERA_OK);
3762 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3763 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
3764 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3765 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3766 } else {
3767 ret = OH_CaptureSession_PreconfigWithRatio(nullptr, preconfigType, preconfigRatio);
3768 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3769 }
3770 }
3771
3772 /*
3773 * Feature: Framework
3774 * Function: Test get active profile of priview output and delete profile of priview output
3775 * SubFunction: NA
3776 * FunctionPoints: NA
3777 * EnvConditions: NA
3778 * CaseDescription: Test get active profile of priview output and delete profile of priview output
3779 */
3780 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_034, TestSize.Level0)
3781 {
3782 Camera_Profile *profile = nullptr;
3783 Camera_CaptureSession* captureSession = nullptr;
3784 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3785 EXPECT_EQ(ret, CAMERA_OK);
3786 ASSERT_NE(captureSession, nullptr);
3787 Camera_Input *cameraInput = nullptr;
3788 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3789 EXPECT_EQ(ret, CAMERA_OK);
3790 ASSERT_NE(&cameraInput, nullptr);
3791 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3792
3793 ret = OH_CaptureSession_BeginConfig(captureSession);
3794 EXPECT_EQ(ret, CAMERA_OK);
3795 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3796 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
3797 ASSERT_NE(previewOutput, nullptr);
3798 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
3799 EXPECT_EQ(ret, CAMERA_OK);
3800 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3801
3802 ret = OH_PreviewOutput_GetActiveProfile(previewOutput, &profile);
3803 EXPECT_EQ(ret, CAMERA_OK);
3804 ret = OH_PreviewOutput_GetActiveProfile(nullptr, &profile);
3805 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3806 ret = OH_PreviewOutput_GetActiveProfile(previewOutput, nullptr);
3807 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3808 EXPECT_EQ(OH_PreviewOutput_Start(previewOutput), CAMERA_OK);
3809 EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), CAMERA_OK);
3810 if (profile != nullptr) {
3811 EXPECT_EQ(OH_PreviewOutput_DeleteProfile(profile), CAMERA_OK);
3812 }
3813 EXPECT_EQ(OH_PreviewOutput_DeleteProfile(nullptr), CAMERA_INVALID_ARGUMENT);
3814 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
3815 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3816 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3817 }
3818
3819 /*
3820 * Feature: Framework
3821 * Function: Test get active profile of photo output and delete profile of photo output
3822 * SubFunction: NA
3823 * FunctionPoints: NA
3824 * EnvConditions: NA
3825 * CaseDescription: Test get active profile of photo output and delete profile of photo output
3826 */
3827 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_035, TestSize.Level0)
3828 {
3829 Camera_Profile* profile = nullptr;
3830 Camera_CaptureSession* captureSession = nullptr;
3831 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3832 EXPECT_EQ(ret, CAMERA_OK);
3833 ASSERT_NE(captureSession, nullptr);
3834 Camera_Input *cameraInput = nullptr;
3835 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3836 EXPECT_EQ(ret, CAMERA_OK);
3837 ASSERT_NE(&cameraInput, nullptr);
3838 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3839
3840 ret = OH_CaptureSession_BeginConfig(captureSession);
3841 EXPECT_EQ(ret, CAMERA_OK);
3842 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3843 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
3844 ASSERT_NE(photooutput, nullptr);
3845 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
3846 EXPECT_EQ(ret, CAMERA_OK);
3847 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3848
3849 ret = OH_PhotoOutput_GetActiveProfile(photooutput, &profile);
3850 EXPECT_EQ(ret, CAMERA_OK);
3851 ret = OH_PhotoOutput_GetActiveProfile(nullptr, &profile);
3852 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3853 ret = OH_PhotoOutput_GetActiveProfile(photooutput, nullptr);
3854 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3855 if (profile != nullptr) {
3856 EXPECT_EQ(OH_PhotoOutput_DeleteProfile(profile), CAMERA_OK);
3857 }
3858 EXPECT_EQ(OH_PhotoOutput_DeleteProfile(nullptr), CAMERA_INVALID_ARGUMENT);
3859 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
3860 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3861 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3862 }
3863
3864 /*
3865 * Feature: Framework
3866 * Function: Test get active profile of video output and delete profile of video output
3867 * SubFunction: NA
3868 * FunctionPoints: NA
3869 * EnvConditions: NA
3870 * CaseDescription: Test get active profile of video output and delete profile of video output
3871 */
3872 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_036, TestSize.Level0)
3873 {
3874 Camera_VideoProfile* videoProfile = nullptr;
3875 Camera_CaptureSession* captureSession = nullptr;
3876 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3877 EXPECT_EQ(ret, CAMERA_OK);
3878 ASSERT_NE(captureSession, nullptr);
3879 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
3880 EXPECT_EQ(ret, CAMERA_OK);
3881 Camera_Input *cameraInput = nullptr;
3882 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3883 EXPECT_EQ(ret, CAMERA_OK);
3884 ASSERT_NE(&cameraInput, nullptr);
3885 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3886
3887 ret = OH_CaptureSession_BeginConfig(captureSession);
3888 EXPECT_EQ(ret, 0);
3889 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0);
3890 Camera_VideoOutput* videoOutput = CreateVideoOutput();
3891 ASSERT_NE(videoOutput, nullptr);
3892 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
3893 EXPECT_EQ(ret, CAMERA_OK);
3894 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3895
3896 ret = OH_VideoOutput_GetActiveProfile(videoOutput, &videoProfile);
3897 EXPECT_EQ(ret, CAMERA_OK);
3898 ret = OH_VideoOutput_GetActiveProfile(nullptr, &videoProfile);
3899 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3900 ret = OH_VideoOutput_GetActiveProfile(videoOutput, nullptr);
3901 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3902 if (videoProfile != nullptr) {
3903 EXPECT_EQ(OH_VideoOutput_DeleteProfile(videoProfile), CAMERA_OK);
3904 }
3905 EXPECT_EQ(OH_VideoOutput_DeleteProfile(nullptr), CAMERA_INVALID_ARGUMENT);
3906 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
3907 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3908 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3909 }
3910
3911 /*
3912 * Feature: Framework
3913 * Function: Test camera orientation
3914 * SubFunction: NA
3915 * FunctionPoints: NA
3916 * EnvConditions: NA
3917 * CaseDescription: Test camera orientation
3918 */
3919 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_037, TestSize.Level0)
3920 {
3921 Camera_Input *cameraInput = nullptr;
3922 Camera_ErrorCode ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3923 EXPECT_EQ(ret, CAMERA_OK);
3924 EXPECT_NE(&cameraInput, nullptr);
3925 ret = OH_CameraInput_Open(cameraInput);
3926 EXPECT_EQ(ret, CAMERA_OK);
3927
3928 uint32_t orientation = 0;
3929 ret = OH_CameraDevice_GetCameraOrientation(cameraDevice, &orientation);
3930 EXPECT_EQ(ret, 0);
3931 ret = OH_CameraInput_Release(cameraInput);
3932 EXPECT_EQ(ret, 0);
3933 }
3934
3935 /*
3936 * Feature: Framework
3937 * Function: Test Torch supported or not and supported or not with torch mode
3938 * SubFunction: NA
3939 * FunctionPoints: NA
3940 * EnvConditions: NA
3941 * CaseDescription: Test is Torch supported or not and supported or not with torch mode
3942 */
3943 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_038, TestSize.Level0)
3944 {
3945 Camera_CaptureSession* captureSession = nullptr;
3946 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
3947 EXPECT_EQ(ret, CAMERA_OK);
3948 ASSERT_NE(captureSession, nullptr);
3949 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
3950 EXPECT_EQ(ret, CAMERA_OK);
3951 ret = OH_CaptureSession_BeginConfig(captureSession);
3952 EXPECT_EQ(ret, CAMERA_OK);
3953 Camera_Input *cameraInput = nullptr;
3954 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
3955 EXPECT_EQ(ret, CAMERA_OK);
3956 ASSERT_NE(&cameraInput, nullptr);
3957 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
3958 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
3959 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
3960 ASSERT_NE(photooutput, nullptr);
3961 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
3962 EXPECT_EQ(ret, CAMERA_OK);
3963 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
3964 bool isTorchSupported = false;
3965 Camera_TorchMode torchMode = ON;
3966 ret = OH_CameraManager_IsTorchSupported(cameraManager, &isTorchSupported);
3967 EXPECT_EQ(ret, CAMERA_OK);
3968 if (isTorchSupported == true) {
3969 ret = OH_CameraManager_IsTorchSupportedByTorchMode(cameraManager, torchMode, &isTorchSupported);
3970 EXPECT_EQ(ret, CAMERA_OK);
3971 if (isTorchSupported == true) {
3972 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
3973 if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_FRONT) {
3974 EXPECT_EQ(ret, CAMERA_OK);
3975 } else if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_BACK) {
3976 EXPECT_EQ(ret, Camera_ErrorCode::CAMERA_OPERATION_NOT_ALLOWED);
3977 }
3978 } else {
3979 ret = OH_CameraManager_IsTorchSupportedByTorchMode(nullptr, torchMode, &isTorchSupported);
3980 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3981 ret = OH_CameraManager_IsTorchSupportedByTorchMode(cameraManager, torchMode, nullptr);
3982 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3983 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
3984 }
3985 } else {
3986 ret = OH_CameraManager_IsTorchSupported(nullptr, &isTorchSupported);
3987 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3988 ret = OH_CameraManager_IsTorchSupported(cameraManager, nullptr);
3989 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
3990 }
3991 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
3992 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
3993 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
3994 }
3995
3996 /*
3997 * Feature: Framework
3998 * Function: Test set torch mode
3999 * SubFunction: NA
4000 * FunctionPoints: NA
4001 * EnvConditions: NA
4002 * CaseDescription: Test set torch mode
4003 */
4004 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_039, TestSize.Level0)
4005 {
4006 Camera_CaptureSession* captureSession = nullptr;
4007 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4008 EXPECT_EQ(ret, CAMERA_OK);
4009 ASSERT_NE(captureSession, nullptr);
4010 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4011 EXPECT_EQ(ret, CAMERA_OK);
4012 ret = OH_CaptureSession_BeginConfig(captureSession);
4013 EXPECT_EQ(ret, CAMERA_OK);
4014 Camera_Input *cameraInput = nullptr;
4015 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4016 EXPECT_EQ(ret, CAMERA_OK);
4017 ASSERT_NE(&cameraInput, nullptr);
4018 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4019 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4020 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4021 ASSERT_NE(photooutput, nullptr);
4022 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4023 EXPECT_EQ(ret, CAMERA_OK);
4024 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4025 bool isTorchSupported = false;
4026 Camera_TorchMode torchMode = ON;
4027 ret = OH_CameraManager_IsTorchSupported(cameraManager, &isTorchSupported);
4028 EXPECT_EQ(ret, CAMERA_OK);
4029 if (isTorchSupported == true) {
4030 ret = OH_CameraManager_IsTorchSupportedByTorchMode(cameraManager, torchMode, &isTorchSupported);
4031 EXPECT_EQ(ret, CAMERA_OK);
4032 if (isTorchSupported == true) {
4033 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
4034 if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_FRONT) {
4035 EXPECT_EQ(ret, CAMERA_OK);
4036 } else if (cameraDevice[CAMERA_DEVICE_INDEX].cameraPosition == Camera_Position::CAMERA_POSITION_BACK) {
4037 EXPECT_EQ(ret, Camera_ErrorCode::CAMERA_OPERATION_NOT_ALLOWED);
4038 }
4039 } else {
4040 ret = OH_CameraManager_SetTorchMode(nullptr, torchMode);
4041 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4042 ret = OH_CameraManager_SetTorchMode(cameraManager, torchMode);
4043 }
4044 }
4045 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4046 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4047 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4048 }
4049
4050 /*
4051 * Feature: Framework
4052 * Function: Test register camera manager callback
4053 * SubFunction: NA
4054 * FunctionPoints: NA
4055 * EnvConditions: NA
4056 * CaseDescription: Test register camera manager callback
4057 */
4058 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_040, TestSize.Level0)
4059 {
4060 CameraManager_Callbacks setCameraManagerResultCallback = {
4061 .onCameraStatus = &CameraManagerOnCameraStatusCb
4062 };
4063 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
4064 EXPECT_EQ(ret, CAMERA_OK);
4065 ret = OH_CameraManager_RegisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
4066 EXPECT_EQ(ret, CAMERA_OK);
4067 ret = OH_CameraManager_RegisterTorchStatusCallback(nullptr, CameraManagerOnCameraTorchStatusCb);
4068 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4069 ret = OH_CameraManager_RegisterTorchStatusCallback(cameraManager, nullptr);
4070 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4071 ret = OH_CameraManager_UnregisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
4072 EXPECT_EQ(ret, CAMERA_OK);
4073 }
4074
4075 /*
4076 * Feature: Framework
4077 * Function: Test unregister camera manager callback
4078 * SubFunction: NA
4079 * FunctionPoints: NA
4080 * EnvConditions: NA
4081 * CaseDescription: Test unregister camera manager callback
4082 */
4083 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_041, TestSize.Level0)
4084 {
4085 CameraManager_Callbacks setCameraManagerResultCallback = {
4086 .onCameraStatus = &CameraManagerOnCameraStatusCb
4087 };
4088 Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback);
4089 EXPECT_EQ(ret, CAMERA_OK);
4090 ret = OH_CameraManager_RegisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
4091 EXPECT_EQ(ret, CAMERA_OK);
4092 ret = OH_CameraManager_UnregisterTorchStatusCallback(cameraManager, CameraManagerOnCameraTorchStatusCb);
4093 EXPECT_EQ(ret, CAMERA_OK);
4094 ret = OH_CameraManager_UnregisterTorchStatusCallback(nullptr, CameraManagerOnCameraTorchStatusCb);
4095 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4096 ret = OH_CameraManager_UnregisterTorchStatusCallback(cameraManager, nullptr);
4097 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4098 }
4099
4100 /*
4101 * Feature: Framework
4102 * Function: Test get exposure value
4103 * SubFunction: NA
4104 * FunctionPoints: NA
4105 * EnvConditions: NA
4106 * CaseDescription: Test get exposure value
4107 */
4108 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_042, TestSize.Level0)
4109 {
4110 float exposureValue = 0.0f;
4111 Camera_CaptureSession* captureSession = nullptr;
4112 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4113 EXPECT_EQ(ret, CAMERA_OK);
4114 ASSERT_NE(captureSession, nullptr);
4115 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4116 EXPECT_EQ(ret, CAMERA_OK);
4117 ret = OH_CaptureSession_BeginConfig(captureSession);
4118 EXPECT_EQ(ret, CAMERA_OK);
4119 Camera_Input *cameraInput = nullptr;
4120 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4121 EXPECT_EQ(ret, CAMERA_OK);
4122 ASSERT_NE(&cameraInput, nullptr);
4123 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4124 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4125 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4126 ASSERT_NE(photooutput, nullptr);
4127 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4128 EXPECT_EQ(ret, CAMERA_OK);
4129 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4130 ret = OH_CaptureSession_GetExposureValue(captureSession, &exposureValue);
4131 EXPECT_EQ(ret, CAMERA_OK);
4132 ret = OH_CaptureSession_GetExposureValue(nullptr, &exposureValue);
4133 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4134 ret = OH_CaptureSession_GetExposureValue(captureSession, nullptr);
4135 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4136 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4137 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4138 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4139 }
4140
4141 /*
4142 * Feature: Framework
4143 * Function: Test get focal length
4144 * SubFunction: NA
4145 * FunctionPoints: NA
4146 * EnvConditions: NA
4147 * CaseDescription: Test get focal length
4148 */
4149 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_043, TestSize.Level0)
4150 {
4151 float focalLength = 0.0f;
4152 Camera_CaptureSession* captureSession = nullptr;
4153 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4154 EXPECT_EQ(ret, CAMERA_OK);
4155 ASSERT_NE(captureSession, nullptr);
4156 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4157 EXPECT_EQ(ret, CAMERA_OK);
4158 ret = OH_CaptureSession_BeginConfig(captureSession);
4159 EXPECT_EQ(ret, CAMERA_OK);
4160 Camera_Input *cameraInput = nullptr;
4161 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4162 EXPECT_EQ(ret, CAMERA_OK);
4163 ASSERT_NE(&cameraInput, nullptr);
4164 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4165 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4166 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4167 ASSERT_NE(photooutput, nullptr);
4168 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4169 EXPECT_EQ(ret, CAMERA_OK);
4170 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4171 ret = OH_CaptureSession_GetFocalLength(captureSession, &focalLength);
4172 EXPECT_EQ(ret, CAMERA_OK);
4173 ret = OH_CaptureSession_GetFocalLength(nullptr, &focalLength);
4174 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4175 ret = OH_CaptureSession_GetFocalLength(captureSession, nullptr);
4176 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4177 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4178 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4179 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4180 }
4181
4182 /*
4183 * Feature: Framework
4184 * Function: Test set smooth zoom
4185 * SubFunction: NA
4186 * FunctionPoints: NA
4187 * EnvConditions: NA
4188 * CaseDescription: Test set smooth zoom
4189 */
4190 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_044, TestSize.Level0)
4191 {
4192 float targetZoom = 0.0f;
4193 Camera_SmoothZoomMode smoothZoomMode = Camera_SmoothZoomMode::NORMAL;
4194 Camera_CaptureSession* captureSession = nullptr;
4195 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4196 EXPECT_EQ(ret, CAMERA_OK);
4197 ASSERT_NE(captureSession, nullptr);
4198 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4199 EXPECT_EQ(ret, CAMERA_OK);
4200 ret = OH_CaptureSession_BeginConfig(captureSession);
4201 EXPECT_EQ(ret, CAMERA_OK);
4202 Camera_Input *cameraInput = nullptr;
4203 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4204 EXPECT_EQ(ret, CAMERA_OK);
4205 ASSERT_NE(&cameraInput, nullptr);
4206 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
4207 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
4208 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
4209 ASSERT_NE(photooutput, nullptr);
4210 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
4211 EXPECT_EQ(ret, CAMERA_OK);
4212 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4213 ret = OH_CaptureSession_SetSmoothZoom(captureSession, targetZoom, smoothZoomMode);
4214 EXPECT_EQ(ret, CAMERA_OK);
4215 ret = OH_CaptureSession_SetSmoothZoom(nullptr, targetZoom, smoothZoomMode);
4216 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4217 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
4218 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4219 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4220 }
4221
4222 /*
4223 * Feature: Framework
4224 * Function: Test get supported color space
4225 * SubFunction: NA
4226 * FunctionPoints: NA
4227 * EnvConditions: NA
4228 * CaseDescription: Test get supported color space
4229 */
4230 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_045, TestSize.Level0)
4231 {
4232 uint32_t size = 0;
4233 OH_NativeBuffer_ColorSpace* colorSpace = nullptr;
4234 Camera_CaptureSession* captureSession = nullptr;
4235 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4236 EXPECT_EQ(ret, CAMERA_OK);
4237 ASSERT_NE(captureSession, nullptr);
4238 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4239 EXPECT_EQ(ret, CAMERA_OK);
4240 ret = OH_CaptureSession_GetSupportedColorSpaces(nullptr, &colorSpace, &size);
4241 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4242 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, nullptr, &size);
4243 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4244 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, nullptr);
4245 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4246 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, &size);
4247 EXPECT_EQ(ret, CAMERA_OK);
4248 Camera_Input *cameraInput = nullptr;
4249 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4250 EXPECT_EQ(ret, CAMERA_OK);
4251 ret = OH_CameraInput_Open(cameraInput);
4252 EXPECT_EQ(ret, CAMERA_OK);
4253 ret = OH_CaptureSession_BeginConfig(captureSession);
4254 EXPECT_EQ(ret, CAMERA_OK);
4255 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4256 EXPECT_EQ(ret, CAMERA_OK);
4257 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4258 ASSERT_NE(photoOutput, nullptr);
4259 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4260 EXPECT_EQ(ret, CAMERA_OK);
4261 if (size != 0 && colorSpace != nullptr) {
4262 ret = OH_CaptureSession_SetActiveColorSpace(captureSession, colorSpace[0]);
4263 EXPECT_EQ(ret, CAMERA_OK);
4264 }
4265 ret = OH_CaptureSession_CommitConfig(captureSession);
4266 EXPECT_EQ(ret, CAMERA_OK);
4267 OH_NativeBuffer_ColorSpace activeColorSpace;
4268 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, &activeColorSpace);
4269 EXPECT_EQ(ret, CAMERA_OK);
4270 if (size != 0 && colorSpace != nullptr) {
4271 ret = OH_CaptureSession_DeleteColorSpaces(captureSession, colorSpace);
4272 EXPECT_EQ(ret, CAMERA_OK);
4273 }
4274 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4275 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4276 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4277 }
4278
4279 /*
4280 * Feature: Framework
4281 * Function: Test set active color space
4282 * SubFunction: NA
4283 * FunctionPoints: NA
4284 * EnvConditions: NA
4285 * CaseDescription: Test set active color space
4286 */
4287 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_046, TestSize.Level0)
4288 {
4289 uint32_t size = 0;
4290 Camera_ErrorCode ret = CAMERA_OK;
4291 OH_NativeBuffer_ColorSpace* colorSpace = nullptr;
4292 Camera_CaptureSession* captureSession = nullptr;
4293 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4294 EXPECT_EQ(ret, CAMERA_OK);
4295 ASSERT_NE(captureSession, nullptr);
4296 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4297 EXPECT_EQ(ret, CAMERA_OK);
4298 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, &size);
4299 EXPECT_EQ(ret, CAMERA_OK);
4300 Camera_Input *cameraInput = nullptr;
4301 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4302 EXPECT_EQ(ret, CAMERA_OK);
4303 ret = OH_CameraInput_Open(cameraInput);
4304 EXPECT_EQ(ret, CAMERA_OK);
4305 ret = OH_CaptureSession_BeginConfig(captureSession);
4306 EXPECT_EQ(ret, CAMERA_OK);
4307 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4308 EXPECT_EQ(ret, CAMERA_OK);
4309 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4310 ASSERT_NE(previewOutput, nullptr);
4311 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4312 EXPECT_EQ(ret, CAMERA_OK);
4313 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4314 ASSERT_NE(photoOutput, nullptr);
4315 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4316 EXPECT_EQ(ret, CAMERA_OK);
4317 if (size != 0 && colorSpace != nullptr) {
4318 ret = OH_CaptureSession_SetActiveColorSpace(captureSession, colorSpace[0]);
4319 EXPECT_EQ(ret, CAMERA_OK);
4320 ret = OH_CaptureSession_SetActiveColorSpace(nullptr, colorSpace[0]);
4321 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4322 }
4323 ret = OH_CaptureSession_CommitConfig(captureSession);
4324 EXPECT_EQ(ret, CAMERA_OK);
4325 OH_NativeBuffer_ColorSpace activeColorSpace;
4326 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, &activeColorSpace);
4327 EXPECT_EQ(ret, CAMERA_OK);
4328 if (size != 0 && colorSpace != nullptr) {
4329 ret = OH_CaptureSession_DeleteColorSpaces(captureSession, colorSpace);
4330 EXPECT_EQ(ret, CAMERA_OK);
4331 }
4332 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4333 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4334 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4335 }
4336
4337 /*
4338 * Feature: Framework
4339 * Function: Test get active color space
4340 * SubFunction: NA
4341 * FunctionPoints: NA
4342 * EnvConditions: NA
4343 * CaseDescription: Test get active color space
4344 */
4345 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_047, TestSize.Level0)
4346 {
4347 uint32_t size = 0;
4348 Camera_ErrorCode ret = CAMERA_OK;
4349 OH_NativeBuffer_ColorSpace* colorSpace = nullptr;
4350 Camera_CaptureSession* captureSession = nullptr;
4351 ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4352 EXPECT_EQ(ret, CAMERA_OK);
4353 ASSERT_NE(captureSession, nullptr);
4354 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4355 EXPECT_EQ(ret, CAMERA_OK);
4356 ret = OH_CaptureSession_GetSupportedColorSpaces(captureSession, &colorSpace, &size);
4357 EXPECT_EQ(ret, CAMERA_OK);
4358 Camera_Input *cameraInput = nullptr;
4359 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4360 EXPECT_EQ(ret, CAMERA_OK);
4361 ret = OH_CameraInput_Open(cameraInput);
4362 EXPECT_EQ(ret, CAMERA_OK);
4363 ret = OH_CaptureSession_BeginConfig(captureSession);
4364 EXPECT_EQ(ret, CAMERA_OK);
4365 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4366 EXPECT_EQ(ret, CAMERA_OK);
4367 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4368 ASSERT_NE(previewOutput, nullptr);
4369 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4370 EXPECT_EQ(ret, CAMERA_OK);
4371 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4372 ASSERT_NE(photoOutput, nullptr);
4373 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4374 EXPECT_EQ(ret, CAMERA_OK);
4375 if (size != 0 && colorSpace != nullptr) {
4376 ret = OH_CaptureSession_SetActiveColorSpace(captureSession, colorSpace[0]);
4377 EXPECT_EQ(ret, CAMERA_OK);
4378 }
4379 ret = OH_CaptureSession_CommitConfig(captureSession);
4380 EXPECT_EQ(ret, CAMERA_OK);
4381 OH_NativeBuffer_ColorSpace activeColorSpace;
4382 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, &activeColorSpace);
4383 EXPECT_EQ(ret, CAMERA_OK);
4384 ret = OH_CaptureSession_GetActiveColorSpace(nullptr, &activeColorSpace);
4385 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4386 ret = OH_CaptureSession_GetActiveColorSpace(captureSession, nullptr);
4387 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4388 if (size != 0 && colorSpace != nullptr) {
4389 ret = OH_CaptureSession_DeleteColorSpaces(captureSession, colorSpace);
4390 EXPECT_EQ(ret, CAMERA_OK);
4391 }
4392 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4393 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4394 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4395 }
4396
4397 /*
4398 * Feature: Framework
4399 * Function: Test register smooth zoom information event callback
4400 * SubFunction: NA
4401 * FunctionPoints: NA
4402 * EnvConditions: NA
4403 * CaseDescription: Test register smooth zoom information event callback
4404 */
4405 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_048, TestSize.Level0)
4406 {
4407 Camera_CaptureSession* captureSession = nullptr;
4408 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4409 EXPECT_EQ(ret, CAMERA_OK);
4410 ASSERT_NE(captureSession, nullptr);
4411 CaptureSession_Callbacks setCaptureSessionResultCallback = {
4412 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
4413 .onError = &CameraCaptureSessionOnErrorCb
4414 };
4415 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
4416 EXPECT_EQ(ret, CAMERA_OK);
4417 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4418 EXPECT_EQ(ret, CAMERA_OK);
4419 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(nullptr, CameraCaptureSessionOnSmoothZoomInfoCb);
4420 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4421 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(captureSession, nullptr);
4422 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4423 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4424 EXPECT_EQ(ret, CAMERA_OK);
4425 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
4426 EXPECT_EQ(ret, CAMERA_OK);
4427 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4428 }
4429
4430 /*
4431 * Feature: Framework
4432 * Function: Test unregister smooth zoom information event callback
4433 * SubFunction: NA
4434 * FunctionPoints: NA
4435 * EnvConditions: NA
4436 * CaseDescription: Test unregister smooth zoom information event callback
4437 */
4438 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_049, TestSize.Level0)
4439 {
4440 Camera_CaptureSession* captureSession = nullptr;
4441 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4442 EXPECT_EQ(ret, CAMERA_OK);
4443 ASSERT_NE(captureSession, nullptr);
4444 CaptureSession_Callbacks setCaptureSessionResultCallback = {
4445 .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb,
4446 .onError = &CameraCaptureSessionOnErrorCb
4447 };
4448 ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback);
4449 EXPECT_EQ(ret, CAMERA_OK);
4450 ret = OH_CaptureSession_RegisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4451 EXPECT_EQ(ret, CAMERA_OK);
4452 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(captureSession, CameraCaptureSessionOnSmoothZoomInfoCb);
4453 EXPECT_EQ(ret, CAMERA_OK);
4454 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(nullptr, CameraCaptureSessionOnSmoothZoomInfoCb);
4455 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4456 ret = OH_CaptureSession_UnregisterSmoothZoomInfoCallback(captureSession, nullptr);
4457 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4458 ret = OH_CaptureSession_UnregisterCallback(captureSession, &setCaptureSessionResultCallback);
4459 EXPECT_EQ(ret, CAMERA_OK);
4460 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4461 }
4462
4463 /*
4464 * Feature: Framework
4465 * Function: Test get supported framerates and delete framerates in preview output
4466 * SubFunction: NA
4467 * FunctionPoints: NA
4468 * EnvConditions: NA
4469 * CaseDescription: Test get supported framerates delete framerates in preview output
4470 */
4471 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_050, TestSize.Level0)
4472 {
4473 uint32_t size = 0;
4474 int32_t minFps = 0;
4475 int32_t maxFps = 0;
4476 Camera_FrameRateRange* frameRateRange = nullptr;
4477 Camera_CaptureSession* captureSession = nullptr;
4478 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4479 EXPECT_EQ(ret, CAMERA_OK);
4480 ASSERT_NE(captureSession, nullptr);
4481 Camera_Input *cameraInput = nullptr;
4482 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4483 ASSERT_NE(cameraInput, nullptr);
4484 EXPECT_EQ(ret, CAMERA_OK);
4485 ret = OH_CameraInput_Open(cameraInput);
4486 EXPECT_EQ(ret, CAMERA_OK);
4487 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4488 ASSERT_NE(previewOutput, nullptr);
4489 ret = OH_PreviewOutput_GetSupportedFrameRates(nullptr, &frameRateRange, &size);
4490 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4491 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, nullptr, &size);
4492 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4493 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, nullptr);
4494 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4495 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, &size);
4496 EXPECT_EQ(ret, CAMERA_OK);
4497 ret = OH_CaptureSession_BeginConfig(captureSession);
4498 EXPECT_EQ(ret, CAMERA_OK);
4499 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4500 EXPECT_EQ(ret, CAMERA_OK);
4501 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4502 EXPECT_EQ(ret, CAMERA_OK);
4503 if (size != 0 && frameRateRange != nullptr) {
4504 ret = OH_PreviewOutput_SetFrameRate(previewOutput, minFps, maxFps);
4505 EXPECT_EQ(ret, CAMERA_OK);
4506 }
4507 ret = OH_CaptureSession_CommitConfig(captureSession);
4508 EXPECT_EQ(ret, CAMERA_OK);
4509 Camera_FrameRateRange activeframeRateRange;
4510 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, &activeframeRateRange);
4511 EXPECT_EQ(ret, CAMERA_OK);
4512 if (size != 0 && frameRateRange != nullptr) {
4513 ret = OH_PreviewOutput_DeleteFrameRates(nullptr, frameRateRange);
4514 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4515 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, nullptr);
4516 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4517 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, frameRateRange);
4518 EXPECT_EQ(ret, CAMERA_OK);
4519 }
4520 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4521 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
4522 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4523 }
4524
4525 /*
4526 * Feature: Framework
4527 * Function: Test set framerate in preview output
4528 * SubFunction: NA
4529 * FunctionPoints: NA
4530 * EnvConditions: NA
4531 * CaseDescription: Test set framerate in preview output
4532 */
4533 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_051, TestSize.Level0)
4534 {
4535 uint32_t size = 0;
4536 int32_t minFps = 0;
4537 int32_t maxFps = 0;
4538 Camera_FrameRateRange* frameRateRange = nullptr;
4539 Camera_CaptureSession* captureSession = nullptr;
4540 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4541 EXPECT_EQ(ret, CAMERA_OK);
4542 ASSERT_NE(captureSession, nullptr);
4543 Camera_Input *cameraInput = nullptr;
4544 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4545 EXPECT_EQ(ret, CAMERA_OK);
4546 ret = OH_CameraInput_Open(cameraInput);
4547 EXPECT_EQ(ret, CAMERA_OK);
4548 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4549 ASSERT_NE(previewOutput, nullptr);
4550 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, &size);
4551 EXPECT_EQ(ret, CAMERA_OK);
4552 ret = OH_CaptureSession_BeginConfig(captureSession);
4553 EXPECT_EQ(ret, CAMERA_OK);
4554 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4555 EXPECT_EQ(ret, CAMERA_OK);
4556 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4557 EXPECT_EQ(ret, CAMERA_OK);
4558 if (size != 0 && frameRateRange != nullptr) {
4559 ret = OH_PreviewOutput_SetFrameRate(nullptr, minFps, maxFps);
4560 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4561 ret = OH_PreviewOutput_SetFrameRate(previewOutput, minFps, maxFps);
4562 EXPECT_EQ(ret, CAMERA_OK);
4563 }
4564 ret = OH_CaptureSession_CommitConfig(captureSession);
4565 EXPECT_EQ(ret, CAMERA_OK);
4566 Camera_FrameRateRange activeframeRateRange;
4567 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, &activeframeRateRange);
4568 EXPECT_EQ(ret, CAMERA_OK);
4569 if (size != 0 && frameRateRange != nullptr) {
4570 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, frameRateRange);
4571 EXPECT_EQ(ret, CAMERA_OK);
4572 }
4573 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4574 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
4575 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4576 }
4577
4578 /*
4579 * Feature: Framework
4580 * Function: Test get active framerate in preview output
4581 * SubFunction: NA
4582 * FunctionPoints: NA
4583 * EnvConditions: NA
4584 * CaseDescription: Test get active framerate in preview output
4585 */
4586 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_052, TestSize.Level0)
4587 {
4588 uint32_t size = 0;
4589 int32_t minFps = 0;
4590 int32_t maxFps = 0;
4591 Camera_FrameRateRange* frameRateRange = nullptr;
4592 Camera_CaptureSession* captureSession = nullptr;
4593 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4594 EXPECT_EQ(ret, CAMERA_OK);
4595 ASSERT_NE(captureSession, nullptr);
4596 Camera_Input *cameraInput = nullptr;
4597 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4598 EXPECT_EQ(ret, CAMERA_OK);
4599 ret = OH_CameraInput_Open(cameraInput);
4600 EXPECT_EQ(ret, CAMERA_OK);
4601 Camera_PreviewOutput* previewOutput = CreatePreviewOutput();
4602 ASSERT_NE(previewOutput, nullptr);
4603 ret = OH_PreviewOutput_GetSupportedFrameRates(previewOutput, &frameRateRange, &size);
4604 EXPECT_EQ(ret, CAMERA_OK);
4605 ret = OH_CaptureSession_BeginConfig(captureSession);
4606 EXPECT_EQ(ret, CAMERA_OK);
4607 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4608 EXPECT_EQ(ret, CAMERA_OK);
4609 ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput);
4610 EXPECT_EQ(ret, CAMERA_OK);
4611 if (size != 0 && frameRateRange != nullptr) {
4612 ret = OH_PreviewOutput_SetFrameRate(previewOutput, minFps, maxFps);
4613 EXPECT_EQ(ret, CAMERA_OK);
4614 }
4615 ret = OH_CaptureSession_CommitConfig(captureSession);
4616 EXPECT_EQ(ret, CAMERA_OK);
4617 Camera_FrameRateRange activeframeRateRange;
4618 ret = OH_PreviewOutput_GetActiveFrameRate(nullptr, &activeframeRateRange);
4619 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4620 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, nullptr);
4621 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4622 ret = OH_PreviewOutput_GetActiveFrameRate(previewOutput, &activeframeRateRange);
4623 EXPECT_EQ(ret, CAMERA_OK);
4624 if (size != 0 && frameRateRange != nullptr) {
4625 ret = OH_PreviewOutput_DeleteFrameRates(previewOutput, frameRateRange);
4626 EXPECT_EQ(ret, CAMERA_OK);
4627 }
4628 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4629 EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), CAMERA_OK);
4630 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4631 }
4632
4633 /*
4634 * Feature: Framework
4635 * Function: Test register photo output capture start event callback
4636 * SubFunction: NA
4637 * FunctionPoints: NA
4638 * EnvConditions: NA
4639 * CaseDescription: Test register photo output capture start event callback
4640 */
4641 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_053, TestSize.Level0)
4642 {
4643 Camera_CaptureSession* captureSession = nullptr;
4644 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4645 EXPECT_EQ(ret, CAMERA_OK);
4646 ASSERT_NE(captureSession, nullptr);
4647 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4648 EXPECT_EQ(ret, CAMERA_OK);
4649 Camera_Input *cameraInput = nullptr;
4650 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4651 EXPECT_EQ(ret, CAMERA_OK);
4652 ret = OH_CameraInput_Open(cameraInput);
4653 EXPECT_EQ(ret, CAMERA_OK);
4654 ret = OH_CaptureSession_BeginConfig(captureSession);
4655 EXPECT_EQ(ret, CAMERA_OK);
4656 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4657 EXPECT_EQ(ret, CAMERA_OK);
4658 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4659 ASSERT_NE(photoOutput, nullptr);
4660 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4661 EXPECT_EQ(ret, CAMERA_OK);
4662 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(nullptr, CameraPhotoOutptOnCaptureStartWithInfoCb);
4663 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4664 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(photoOutput, nullptr);
4665 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4666 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4667 EXPECT_EQ(ret, CAMERA_OK);
4668 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4669 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4670 EXPECT_EQ(ret, CAMERA_OK);
4671 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4672 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4673 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4674 }
4675
4676 /*
4677 * Feature: Framework
4678 * Function: Test unregister photo output capture start event callback
4679 * SubFunction: NA
4680 * FunctionPoints: NA
4681 * EnvConditions: NA
4682 * CaseDescription: Test unregister photo output capture start event callback
4683 */
4684 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_054, TestSize.Level0)
4685 {
4686 Camera_CaptureSession* captureSession = nullptr;
4687 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4688 EXPECT_EQ(ret, CAMERA_OK);
4689 ASSERT_NE(captureSession, nullptr);
4690 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4691 EXPECT_EQ(ret, CAMERA_OK);
4692 Camera_Input *cameraInput = nullptr;
4693 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4694 EXPECT_EQ(ret, CAMERA_OK);
4695 ret = OH_CameraInput_Open(cameraInput);
4696 EXPECT_EQ(ret, CAMERA_OK);
4697 ret = OH_CaptureSession_BeginConfig(captureSession);
4698 EXPECT_EQ(ret, CAMERA_OK);
4699 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4700 EXPECT_EQ(ret, CAMERA_OK);
4701 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4702 ASSERT_NE(photoOutput, nullptr);
4703 ret = OH_PhotoOutput_RegisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4704 EXPECT_EQ(ret, CAMERA_OK);
4705 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4706 EXPECT_EQ(ret, CAMERA_OK);
4707 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4708 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(photoOutput, CameraPhotoOutptOnCaptureStartWithInfoCb);
4709 EXPECT_EQ(ret, CAMERA_OK);
4710 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(nullptr, CameraPhotoOutptOnCaptureStartWithInfoCb);
4711 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4712 ret = OH_PhotoOutput_UnregisterCaptureStartWithInfoCallback(photoOutput, nullptr);
4713 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4714 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4715 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4716 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4717 }
4718
4719 /*
4720 * Feature: Framework
4721 * Function: Test register photo output capture end event callback
4722 * SubFunction: NA
4723 * FunctionPoints: NA
4724 * EnvConditions: NA
4725 * CaseDescription: Test register photo output capture end event callback
4726 */
4727 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_055, TestSize.Level0)
4728 {
4729 Camera_CaptureSession* captureSession = nullptr;
4730 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4731 EXPECT_EQ(ret, CAMERA_OK);
4732 ASSERT_NE(captureSession, nullptr);
4733 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4734 EXPECT_EQ(ret, CAMERA_OK);
4735 Camera_Input *cameraInput = nullptr;
4736 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4737 EXPECT_EQ(ret, CAMERA_OK);
4738 ret = OH_CameraInput_Open(cameraInput);
4739 EXPECT_EQ(ret, CAMERA_OK);
4740 ret = OH_CaptureSession_BeginConfig(captureSession);
4741 EXPECT_EQ(ret, CAMERA_OK);
4742 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4743 EXPECT_EQ(ret, CAMERA_OK);
4744 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4745 ASSERT_NE(photoOutput, nullptr);
4746 ret = OH_PhotoOutput_RegisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4747 EXPECT_EQ(ret, CAMERA_OK);
4748 ret = OH_PhotoOutput_RegisterCaptureEndCallback(nullptr, CameraPhotoOutptOnCaptureEndCb);
4749 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4750 ret = OH_PhotoOutput_RegisterCaptureEndCallback(photoOutput, nullptr);
4751 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4752 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4753 EXPECT_EQ(ret, CAMERA_OK);
4754 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4755 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4756 EXPECT_EQ(ret, CAMERA_OK);
4757 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4758 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4759 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4760 }
4761
4762 /*
4763 * Feature: Framework
4764 * Function: Test unregister photo output capture end event callback
4765 * SubFunction: NA
4766 * FunctionPoints: NA
4767 * EnvConditions: NA
4768 * CaseDescription: Test unregister photo output capture end event callback
4769 */
4770 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_056, TestSize.Level0)
4771 {
4772 Camera_CaptureSession* captureSession = nullptr;
4773 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4774 EXPECT_EQ(ret, CAMERA_OK);
4775 ASSERT_NE(captureSession, nullptr);
4776 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4777 EXPECT_EQ(ret, CAMERA_OK);
4778 Camera_Input *cameraInput = nullptr;
4779 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4780 EXPECT_EQ(ret, CAMERA_OK);
4781 ret = OH_CameraInput_Open(cameraInput);
4782 EXPECT_EQ(ret, CAMERA_OK);
4783 ret = OH_CaptureSession_BeginConfig(captureSession);
4784 EXPECT_EQ(ret, CAMERA_OK);
4785 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4786 EXPECT_EQ(ret, CAMERA_OK);
4787 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4788 ASSERT_NE(photoOutput, nullptr);
4789 ret = OH_PhotoOutput_RegisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4790 EXPECT_EQ(ret, CAMERA_OK);
4791 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4792 EXPECT_EQ(ret, CAMERA_OK);
4793 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4794 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(photoOutput, CameraPhotoOutptOnCaptureEndCb);
4795 EXPECT_EQ(ret, CAMERA_OK);
4796 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(nullptr, CameraPhotoOutptOnCaptureEndCb);
4797 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4798 ret = OH_PhotoOutput_UnregisterCaptureEndCallback(photoOutput, nullptr);
4799 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4800 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4801 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4802 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4803 }
4804
4805 /*
4806 * Feature: Framework
4807 * Function: Test register photo output shutter end event callback
4808 * SubFunction: NA
4809 * FunctionPoints: NA
4810 * EnvConditions: NA
4811 * CaseDescription: Test register photo output shutter end event callback
4812 */
4813 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_057, TestSize.Level0)
4814 {
4815 Camera_CaptureSession* captureSession = nullptr;
4816 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4817 EXPECT_EQ(ret, CAMERA_OK);
4818 ASSERT_NE(captureSession, nullptr);
4819 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4820 EXPECT_EQ(ret, CAMERA_OK);
4821 Camera_Input *cameraInput = nullptr;
4822 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4823 EXPECT_EQ(ret, CAMERA_OK);
4824 ret = OH_CameraInput_Open(cameraInput);
4825 EXPECT_EQ(ret, CAMERA_OK);
4826 ret = OH_CaptureSession_BeginConfig(captureSession);
4827 EXPECT_EQ(ret, CAMERA_OK);
4828 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4829 EXPECT_EQ(ret, CAMERA_OK);
4830 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4831 ASSERT_NE(photoOutput, nullptr);
4832 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4833 EXPECT_EQ(ret, CAMERA_OK);
4834 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(nullptr, CameraPhotoOutptOnFrameShutterEndCb);
4835 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4836 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(photoOutput, nullptr);
4837 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4838 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4839 EXPECT_EQ(ret, CAMERA_OK);
4840 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4841 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4842 EXPECT_EQ(ret, CAMERA_OK);
4843 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4844 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4845 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4846 }
4847
4848 /*
4849 * Feature: Framework
4850 * Function: Test unregister photo output frame shutter end event callback
4851 * SubFunction: NA
4852 * FunctionPoints: NA
4853 * EnvConditions: NA
4854 * CaseDescription: Test unregister photo output frame shutter end event callback
4855 */
4856 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_058, TestSize.Level0)
4857 {
4858 Camera_CaptureSession* captureSession = nullptr;
4859 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4860 EXPECT_EQ(ret, CAMERA_OK);
4861 ASSERT_NE(captureSession, nullptr);
4862 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4863 EXPECT_EQ(ret, CAMERA_OK);
4864 Camera_Input *cameraInput = nullptr;
4865 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4866 EXPECT_EQ(ret, CAMERA_OK);
4867 ret = OH_CameraInput_Open(cameraInput);
4868 EXPECT_EQ(ret, CAMERA_OK);
4869 ret = OH_CaptureSession_BeginConfig(captureSession);
4870 EXPECT_EQ(ret, CAMERA_OK);
4871 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4872 EXPECT_EQ(ret, CAMERA_OK);
4873 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4874 ASSERT_NE(photoOutput, nullptr);
4875 ret = OH_PhotoOutput_RegisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4876 EXPECT_EQ(ret, CAMERA_OK);
4877 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4878 EXPECT_EQ(ret, CAMERA_OK);
4879 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4880 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(photoOutput, CameraPhotoOutptOnFrameShutterEndCb);
4881 EXPECT_EQ(ret, CAMERA_OK);
4882 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(nullptr, CameraPhotoOutptOnFrameShutterEndCb);
4883 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4884 ret = OH_PhotoOutput_UnregisterFrameShutterEndCallback(photoOutput, nullptr);
4885 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4886 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4887 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4888 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4889 }
4890
4891 /*
4892 * Feature: Framework
4893 * Function: Test register photo output capture ready event callback
4894 * SubFunction: NA
4895 * FunctionPoints: NA
4896 * EnvConditions: NA
4897 * CaseDescription: Test register photo output capture ready event callback
4898 */
4899 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_059, TestSize.Level0)
4900 {
4901 Camera_CaptureSession* captureSession = nullptr;
4902 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4903 EXPECT_EQ(ret, CAMERA_OK);
4904 ASSERT_NE(captureSession, nullptr);
4905 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4906 EXPECT_EQ(ret, CAMERA_OK);
4907 Camera_Input *cameraInput = nullptr;
4908 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4909 EXPECT_EQ(ret, CAMERA_OK);
4910 ret = OH_CameraInput_Open(cameraInput);
4911 EXPECT_EQ(ret, CAMERA_OK);
4912 ret = OH_CaptureSession_BeginConfig(captureSession);
4913 EXPECT_EQ(ret, CAMERA_OK);
4914 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4915 EXPECT_EQ(ret, CAMERA_OK);
4916 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4917 ASSERT_NE(photoOutput, nullptr);
4918 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4919 EXPECT_EQ(ret, CAMERA_OK);
4920 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(nullptr, CameraPhotoOutptOnCaptureReadyCb);
4921 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4922 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(photoOutput, nullptr);
4923 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4924 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4925 EXPECT_EQ(ret, CAMERA_OK);
4926 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4927 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4928 EXPECT_EQ(ret, CAMERA_OK);
4929 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(nullptr, CameraPhotoOutptOnCaptureReadyCb);
4930 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4931 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, nullptr);
4932 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4933 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4934 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4935 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4936 }
4937
4938 /*
4939 * Feature: Framework
4940 * Function: Test unregister photo output capture ready event callback
4941 * SubFunction: NA
4942 * FunctionPoints: NA
4943 * EnvConditions: NA
4944 * CaseDescription: Test unregister photo output capture ready event callback
4945 */
4946 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_060, TestSize.Level0)
4947 {
4948 Camera_CaptureSession* captureSession = nullptr;
4949 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4950 EXPECT_EQ(ret, CAMERA_OK);
4951 ASSERT_NE(captureSession, nullptr);
4952 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4953 EXPECT_EQ(ret, CAMERA_OK);
4954 Camera_Input *cameraInput = nullptr;
4955 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4956 EXPECT_EQ(ret, CAMERA_OK);
4957 ret = OH_CameraInput_Open(cameraInput);
4958 EXPECT_EQ(ret, CAMERA_OK);
4959 ret = OH_CaptureSession_BeginConfig(captureSession);
4960 EXPECT_EQ(ret, CAMERA_OK);
4961 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
4962 EXPECT_EQ(ret, CAMERA_OK);
4963 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
4964 ASSERT_NE(photoOutput, nullptr);
4965 ret = OH_PhotoOutput_RegisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4966 EXPECT_EQ(ret, CAMERA_OK);
4967 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
4968 EXPECT_EQ(ret, CAMERA_OK);
4969 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
4970 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, CameraPhotoOutptOnCaptureReadyCb);
4971 EXPECT_EQ(ret, CAMERA_OK);
4972 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(nullptr, CameraPhotoOutptOnCaptureReadyCb);
4973 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4974 ret = OH_PhotoOutput_UnregisterCaptureReadyCallback(photoOutput, nullptr);
4975 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
4976 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
4977 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
4978 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
4979 }
4980
4981 /*
4982 * Feature: Framework
4983 * Function: Test register photo output estimated capture duration event callback
4984 * SubFunction: NA
4985 * FunctionPoints: NA
4986 * EnvConditions: NA
4987 * CaseDescription: Test register photo output estimated capture duration event callback
4988 */
4989 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_061, TestSize.Level0)
4990 {
4991 Camera_CaptureSession* captureSession = nullptr;
4992 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
4993 EXPECT_EQ(ret, CAMERA_OK);
4994 ASSERT_NE(captureSession, nullptr);
4995 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
4996 EXPECT_EQ(ret, CAMERA_OK);
4997 Camera_Input *cameraInput = nullptr;
4998 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
4999 EXPECT_EQ(ret, CAMERA_OK);
5000 ret = OH_CameraInput_Open(cameraInput);
5001 EXPECT_EQ(ret, CAMERA_OK);
5002 ret = OH_CaptureSession_BeginConfig(captureSession);
5003 EXPECT_EQ(ret, CAMERA_OK);
5004 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5005 EXPECT_EQ(ret, CAMERA_OK);
5006 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
5007 ASSERT_NE(photoOutput, nullptr);
5008 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(photoOutput,
5009 CameraPhotoOutptEstimatedOnCaptureDurationCb);
5010 EXPECT_EQ(ret, CAMERA_OK);
5011 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(nullptr,
5012 CameraPhotoOutptEstimatedOnCaptureDurationCb);
5013 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5014 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(photoOutput, nullptr);
5015 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5016 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5017 EXPECT_EQ(ret, CAMERA_OK);
5018 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5019 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(photoOutput,
5020 CameraPhotoOutptEstimatedOnCaptureDurationCb);
5021 EXPECT_EQ(ret, CAMERA_OK);
5022 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5023 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5024 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5025 }
5026
5027 /*
5028 * Feature: Framework
5029 * Function: Test unregister photo output estimated capture duration event callback
5030 * SubFunction: NA
5031 * FunctionPoints: NA
5032 * EnvConditions: NA
5033 * CaseDescription: Test unregister photo output estimated capture duration event callback
5034 */
5035 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_062, TestSize.Level0)
5036 {
5037 Camera_CaptureSession* captureSession = nullptr;
5038 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5039 EXPECT_EQ(ret, CAMERA_OK);
5040 ASSERT_NE(captureSession, nullptr);
5041 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5042 EXPECT_EQ(ret, CAMERA_OK);
5043 Camera_Input *cameraInput = nullptr;
5044 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5045 EXPECT_EQ(ret, CAMERA_OK);
5046 ret = OH_CameraInput_Open(cameraInput);
5047 EXPECT_EQ(ret, CAMERA_OK);
5048 ret = OH_CaptureSession_BeginConfig(captureSession);
5049 EXPECT_EQ(ret, CAMERA_OK);
5050 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5051 EXPECT_EQ(ret, CAMERA_OK);
5052 Camera_PhotoOutput* photoOutput = CreatePhotoOutput();
5053 ASSERT_NE(photoOutput, nullptr);
5054 ret = OH_PhotoOutput_RegisterEstimatedCaptureDurationCallback(photoOutput,
5055 CameraPhotoOutptEstimatedOnCaptureDurationCb);
5056 EXPECT_EQ(ret, CAMERA_OK);
5057 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5058 EXPECT_EQ(ret, CAMERA_OK);
5059 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5060 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(photoOutput,
5061 CameraPhotoOutptEstimatedOnCaptureDurationCb);
5062 EXPECT_EQ(ret, CAMERA_OK);
5063 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(nullptr,
5064 CameraPhotoOutptEstimatedOnCaptureDurationCb);
5065 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5066 ret = OH_PhotoOutput_UnregisterEstimatedCaptureDurationCallback(photoOutput, nullptr);
5067 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5068 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5069 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5070 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5071 }
5072
5073 /*
5074 * Feature: Framework
5075 * Function: Test get supported framerates and delete framerates in video output
5076 * SubFunction: NA
5077 * FunctionPoints: NA
5078 * EnvConditions: NA
5079 * CaseDescription: Test get supported framerates and delete framerates in video output
5080 */
5081 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_063, TestSize.Level0)
5082 {
5083 uint32_t size = 0;
5084 int32_t minFps = 0;
5085 int32_t maxFps = 0;
5086 Camera_FrameRateRange* frameRateRange = nullptr;
5087 Camera_CaptureSession* captureSession = nullptr;
5088 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5089 EXPECT_EQ(ret, CAMERA_OK);
5090 ASSERT_NE(captureSession, nullptr);
5091 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
5092 EXPECT_EQ(ret, CAMERA_OK);
5093 Camera_Input *cameraInput = nullptr;
5094 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5095 EXPECT_EQ(ret, CAMERA_OK);
5096 ret = OH_CameraInput_Open(cameraInput);
5097 EXPECT_EQ(ret, CAMERA_OK);
5098 Camera_VideoOutput* videoOutput = CreateVideoOutput();
5099 ASSERT_NE(videoOutput, nullptr);
5100 ret = OH_VideoOutput_GetSupportedFrameRates(nullptr, &frameRateRange, &size);
5101 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5102 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, nullptr, &size);
5103 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5104 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, nullptr);
5105 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5106 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, &size);
5107 EXPECT_EQ(ret, CAMERA_OK);
5108 ret = OH_CaptureSession_BeginConfig(captureSession);
5109 EXPECT_EQ(ret, CAMERA_OK);
5110 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5111 EXPECT_EQ(ret, CAMERA_OK);
5112 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
5113 EXPECT_EQ(ret, CAMERA_OK);
5114 if (size != 0 && frameRateRange != nullptr) {
5115 ret = OH_VideoOutput_SetFrameRate(videoOutput, minFps, maxFps);
5116 EXPECT_EQ(ret, CAMERA_OK);
5117 }
5118 ret = OH_CaptureSession_CommitConfig(captureSession);
5119 EXPECT_EQ(ret, CAMERA_OK);
5120 Camera_FrameRateRange activeframeRateRange;
5121 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, &activeframeRateRange);
5122 EXPECT_EQ(ret, CAMERA_OK);
5123 if (size != 0 && frameRateRange != nullptr) {
5124 ret = OH_VideoOutput_DeleteFrameRates(nullptr, frameRateRange);
5125 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5126 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, nullptr);
5127 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5128 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, frameRateRange);
5129 EXPECT_EQ(ret, CAMERA_OK);
5130 }
5131 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5132 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
5133 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5134 }
5135
5136 /*
5137 * Feature: Framework
5138 * Function: Test set framerate in video output
5139 * SubFunction: NA
5140 * FunctionPoints: NA
5141 * EnvConditions: NA
5142 * CaseDescription: Test set framerate in video output
5143 */
5144 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_064, TestSize.Level0)
5145 {
5146 uint32_t size = 0;
5147 int32_t minFps = 0;
5148 int32_t maxFps = 0;
5149 Camera_FrameRateRange* frameRateRange = nullptr;
5150 Camera_CaptureSession* captureSession = nullptr;
5151 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5152 EXPECT_EQ(ret, CAMERA_OK);
5153 ASSERT_NE(captureSession, nullptr);
5154 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
5155 EXPECT_EQ(ret, CAMERA_OK);
5156 Camera_Input *cameraInput = nullptr;
5157 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5158 EXPECT_EQ(ret, CAMERA_OK);
5159 ret = OH_CameraInput_Open(cameraInput);
5160 EXPECT_EQ(ret, CAMERA_OK);
5161 Camera_VideoOutput* videoOutput = CreateVideoOutput();
5162 ASSERT_NE(videoOutput, nullptr);
5163 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, &size);
5164 EXPECT_EQ(ret, CAMERA_OK);
5165 ret = OH_CaptureSession_BeginConfig(captureSession);
5166 EXPECT_EQ(ret, CAMERA_OK);
5167 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5168 EXPECT_EQ(ret, CAMERA_OK);
5169 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
5170 EXPECT_EQ(ret, 0);
5171 if (size != 0 && frameRateRange != nullptr) {
5172 ret = OH_VideoOutput_SetFrameRate(nullptr, minFps, maxFps);
5173 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5174 ret = OH_VideoOutput_SetFrameRate(videoOutput, minFps, maxFps);
5175 EXPECT_EQ(ret, CAMERA_OK);
5176 }
5177 ret = OH_CaptureSession_CommitConfig(captureSession);
5178 EXPECT_EQ(ret, CAMERA_OK);
5179 Camera_FrameRateRange activeframeRateRange;
5180 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, &activeframeRateRange);
5181 EXPECT_EQ(ret, CAMERA_OK);
5182 if (size != 0 && frameRateRange != nullptr) {
5183 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, frameRateRange);
5184 EXPECT_EQ(ret, CAMERA_OK);
5185 }
5186 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5187 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
5188 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5189 }
5190
5191 /*
5192 * Feature: Framework
5193 * Function: Test get active framerate in video output
5194 * SubFunction: NA
5195 * FunctionPoints: NA
5196 * EnvConditions: NA
5197 * CaseDescription: Test get active framerate in video output
5198 */
5199 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_065, TestSize.Level0)
5200 {
5201 uint32_t size = 0;
5202 int32_t minFps = 0;
5203 int32_t maxFps = 0;
5204 Camera_FrameRateRange* frameRateRange = nullptr;
5205 Camera_CaptureSession* captureSession = nullptr;
5206 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5207 EXPECT_EQ(ret, CAMERA_OK);
5208 ASSERT_NE(captureSession, nullptr);
5209 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_VIDEO);
5210 EXPECT_EQ(ret, CAMERA_OK);
5211 Camera_Input *cameraInput = nullptr;
5212 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5213 EXPECT_EQ(ret, CAMERA_OK);
5214 ret = OH_CameraInput_Open(cameraInput);
5215 EXPECT_EQ(ret, CAMERA_OK);
5216 Camera_VideoOutput* videoOutput = CreateVideoOutput();
5217 ASSERT_NE(videoOutput, nullptr);
5218 ret = OH_VideoOutput_GetSupportedFrameRates(videoOutput, &frameRateRange, &size);
5219 EXPECT_EQ(ret, CAMERA_OK);
5220 ret = OH_CaptureSession_BeginConfig(captureSession);
5221 EXPECT_EQ(ret, CAMERA_OK);
5222 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5223 EXPECT_EQ(ret, CAMERA_OK);
5224 ret = OH_CaptureSession_AddVideoOutput(captureSession, videoOutput);
5225 EXPECT_EQ(ret, CAMERA_OK);
5226 if (size != 0 && frameRateRange != nullptr) {
5227 ret = OH_VideoOutput_SetFrameRate(videoOutput, minFps, maxFps);
5228 EXPECT_EQ(ret, CAMERA_OK);
5229 }
5230 ret = OH_CaptureSession_CommitConfig(captureSession);
5231 EXPECT_EQ(ret, CAMERA_OK);
5232 Camera_FrameRateRange activeframeRateRange;
5233 ret = OH_VideoOutput_GetActiveFrameRate(nullptr, &activeframeRateRange);
5234 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5235 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, nullptr);
5236 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5237 ret = OH_VideoOutput_GetActiveFrameRate(videoOutput, &activeframeRateRange);
5238 EXPECT_EQ(ret, CAMERA_OK);
5239 if (size != 0 && frameRateRange != nullptr) {
5240 ret = OH_VideoOutput_DeleteFrameRates(videoOutput, frameRateRange);
5241 EXPECT_EQ(ret, CAMERA_OK);
5242 }
5243 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5244 EXPECT_EQ(OH_VideoOutput_Release(videoOutput), CAMERA_OK);
5245 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5246 }
5247
5248 /*
5249 * Feature: Framework
5250 * Function: Test create photo output without surface
5251 * SubFunction: NA
5252 * FunctionPoints: NA
5253 * EnvConditions: NA
5254 * CaseDescription: Test create photo output without surface
5255 */
5256 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_066, TestSize.Level0)
5257 {
5258 Camera_Size photoSize = {
5259 .width = 10,
5260 .height = 10
5261 };
5262 Camera_Profile profile = {
5263 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5264 .size = photoSize
5265 };
5266 Camera_CaptureSession* captureSession = nullptr;
5267 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5268 EXPECT_EQ(ret, CAMERA_OK);
5269 ASSERT_NE(captureSession, nullptr);
5270 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5271 EXPECT_EQ(ret, CAMERA_OK);
5272 ret = OH_CaptureSession_BeginConfig(captureSession);
5273 EXPECT_EQ(ret, CAMERA_OK);
5274 Camera_Input *cameraInput = nullptr;
5275 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5276 EXPECT_EQ(ret, CAMERA_OK);
5277 ASSERT_NE(&cameraInput, nullptr);
5278 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
5279 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
5280 Camera_PhotoOutput *photoOutput = nullptr;
5281 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(nullptr, &profile, &photoOutput);
5282 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5283 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, nullptr, &photoOutput);
5284 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5285 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, nullptr);
5286 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5287 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5288 EXPECT_EQ(ret, CAMERA_OK);
5289 ASSERT_NE(photoOutput, nullptr);
5290 bool isSuccessful = false;
5291 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5292 EXPECT_EQ(ret, CAMERA_OK);
5293 if (isSuccessful == true) {
5294 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5295 EXPECT_EQ(ret, CAMERA_OK);
5296 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5297 }
5298 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5299 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5300 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5301 }
5302
5303 /*
5304 * Feature: Framework
5305 * Function: Test register photo available callback
5306 * SubFunction: NA
5307 * FunctionPoints: NA
5308 * EnvConditions: NA
5309 * CaseDescription: Test register photo available callback
5310 */
5311 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_067, TestSize.Level0)
5312 {
5313 Camera_Size photoSize = {
5314 .width = 10,
5315 .height = 10
5316 };
5317 Camera_Profile profile = {
5318 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5319 .size = photoSize
5320 };
5321 Camera_CaptureSession* captureSession = nullptr;
5322 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5323 EXPECT_EQ(ret, CAMERA_OK);
5324 ASSERT_NE(captureSession, nullptr);
5325 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5326 EXPECT_EQ(ret, CAMERA_OK);
5327 Camera_Input *cameraInput = nullptr;
5328 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5329 EXPECT_EQ(ret, CAMERA_OK);
5330 ret = OH_CameraInput_Open(cameraInput);
5331 EXPECT_EQ(ret, CAMERA_OK);
5332 ret = OH_CaptureSession_BeginConfig(captureSession);
5333 EXPECT_EQ(ret, CAMERA_OK);
5334 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5335 EXPECT_EQ(ret, CAMERA_OK);
5336 Camera_PhotoOutput *photoOutput = nullptr;
5337 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5338 EXPECT_EQ(ret, CAMERA_OK);
5339 bool isSuccessful = false;
5340 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5341 EXPECT_EQ(ret, CAMERA_OK);
5342 if (isSuccessful == true) {
5343 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5344 EXPECT_EQ(ret, CAMERA_OK);
5345 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5346 EXPECT_EQ(ret, CAMERA_OK);
5347 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5348 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5349 EXPECT_EQ(ret, CAMERA_OK);
5350 } else {
5351 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(photoOutput, nullptr);
5352 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5353 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAvailableCb);
5354 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5355 }
5356 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5357 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5358 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5359 }
5360
5361 /*
5362 * Feature: Framework
5363 * Function: Test unregister photo available callback
5364 * SubFunction: NA
5365 * FunctionPoints: NA
5366 * EnvConditions: NA
5367 * CaseDescription: Test unregister photo available callback
5368 */
5369 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_068, TestSize.Level0)
5370 {
5371 Camera_Size photoSize = {
5372 .width = 10,
5373 .height = 10
5374 };
5375 Camera_Profile profile = {
5376 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5377 .size = photoSize
5378 };
5379 Camera_CaptureSession* captureSession = nullptr;
5380 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5381 EXPECT_EQ(ret, CAMERA_OK);
5382 ASSERT_NE(captureSession, nullptr);
5383 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5384 EXPECT_EQ(ret, CAMERA_OK);
5385 Camera_Input *cameraInput = nullptr;
5386 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5387 EXPECT_EQ(ret, CAMERA_OK);
5388 ret = OH_CameraInput_Open(cameraInput);
5389 EXPECT_EQ(ret, CAMERA_OK);
5390 ret = OH_CaptureSession_BeginConfig(captureSession);
5391 EXPECT_EQ(ret, CAMERA_OK);
5392 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5393 EXPECT_EQ(ret, CAMERA_OK);
5394 Camera_PhotoOutput *photoOutput = nullptr;
5395 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5396 EXPECT_EQ(ret, CAMERA_OK);
5397 bool isSuccessful = false;
5398 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5399 EXPECT_EQ(ret, CAMERA_OK);
5400 if (isSuccessful == true) {
5401 ret = OH_PhotoOutput_RegisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5402 EXPECT_EQ(ret, CAMERA_OK);
5403 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5404 EXPECT_EQ(ret, CAMERA_OK);
5405 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5406 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAvailableCb);
5407 EXPECT_EQ(ret, CAMERA_OK);
5408 } else {
5409 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAvailableCb);
5410 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5411 ret = OH_PhotoOutput_UnregisterPhotoAvailableCallback(photoOutput, nullptr);
5412 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5413 }
5414 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5415 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5416 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5417 }
5418
5419 /*
5420 * Feature: Framework
5421 * Function: Test register photo asset available callback
5422 * SubFunction: NA
5423 * FunctionPoints: NA
5424 * EnvConditions: NA
5425 * CaseDescription: Test register photo asset available callback
5426 */
5427 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_069, TestSize.Level0)
5428 {
5429 Camera_Size photoSize = {
5430 .width = 10,
5431 .height = 10
5432 };
5433 Camera_Profile profile = {
5434 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5435 .size = photoSize
5436 };
5437 Camera_CaptureSession* captureSession = nullptr;
5438 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5439 EXPECT_EQ(ret, CAMERA_OK);
5440 ASSERT_NE(captureSession, nullptr);
5441 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5442 EXPECT_EQ(ret, CAMERA_OK);
5443 Camera_Input *cameraInput = nullptr;
5444 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5445 EXPECT_EQ(ret, CAMERA_OK);
5446 ret = OH_CameraInput_Open(cameraInput);
5447 EXPECT_EQ(ret, CAMERA_OK);
5448 ret = OH_CaptureSession_BeginConfig(captureSession);
5449 EXPECT_EQ(ret, CAMERA_OK);
5450 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5451 EXPECT_EQ(ret, CAMERA_OK);
5452 Camera_PhotoOutput *photoOutput = nullptr;
5453 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5454 EXPECT_EQ(ret, CAMERA_OK);
5455 bool isSuccessful = false;
5456 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5457 EXPECT_EQ(ret, CAMERA_OK);
5458 if (isSuccessful == true) {
5459 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAssetAvailableCb);
5460 EXPECT_EQ(ret, CAMERA_OK);
5461 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5462 EXPECT_EQ(ret, CAMERA_OK);
5463 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5464 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(photoOutput,
5465 CameraPhotoOutptOnPhotoAssetAvailableCb);
5466 EXPECT_EQ(ret, CAMERA_OK);
5467 } else {
5468 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(photoOutput, nullptr);
5469 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5470 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAssetAvailableCb);
5471 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5472 }
5473 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5474 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5475 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5476 }
5477
5478 /*
5479 * Feature: Framework
5480 * Function: Test unregister photo asset available callback
5481 * SubFunction: NA
5482 * FunctionPoints: NA
5483 * EnvConditions: NA
5484 * CaseDescription: Test unregister photo asset available callback
5485 */
5486 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_070, TestSize.Level0)
5487 {
5488 Camera_Size photoSize = {
5489 .width = 10,
5490 .height = 10
5491 };
5492 Camera_Profile profile = {
5493 .format = Camera_Format::CAMERA_FORMAT_JPEG,
5494 .size = photoSize
5495 };
5496 Camera_CaptureSession* captureSession = nullptr;
5497 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5498 EXPECT_EQ(ret, CAMERA_OK);
5499 ASSERT_NE(captureSession, nullptr);
5500 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5501 EXPECT_EQ(ret, CAMERA_OK);
5502 Camera_Input *cameraInput = nullptr;
5503 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5504 EXPECT_EQ(ret, CAMERA_OK);
5505 ret = OH_CameraInput_Open(cameraInput);
5506 EXPECT_EQ(ret, CAMERA_OK);
5507 ret = OH_CaptureSession_BeginConfig(captureSession);
5508 EXPECT_EQ(ret, CAMERA_OK);
5509 ret = OH_CaptureSession_AddInput(captureSession, cameraInput);
5510 EXPECT_EQ(ret, CAMERA_OK);
5511 Camera_PhotoOutput *photoOutput = nullptr;
5512 ret = OH_CameraManager_CreatePhotoOutputWithoutSurface(cameraManager, &profile, &photoOutput);
5513 EXPECT_EQ(ret, CAMERA_OK);
5514 bool isSuccessful = false;
5515 ret = OH_CaptureSession_CanAddPhotoOutput(captureSession, photoOutput, &isSuccessful);
5516 EXPECT_EQ(ret, CAMERA_OK);
5517 if (isSuccessful == true) {
5518 ret = OH_PhotoOutput_RegisterPhotoAssetAvailableCallback(photoOutput, CameraPhotoOutptOnPhotoAssetAvailableCb);
5519 EXPECT_EQ(ret, CAMERA_OK);
5520 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput);
5521 EXPECT_EQ(ret, CAMERA_OK);
5522 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5523 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(photoOutput,
5524 CameraPhotoOutptOnPhotoAssetAvailableCb);
5525 EXPECT_EQ(ret, CAMERA_OK);
5526 } else {
5527 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(nullptr, CameraPhotoOutptOnPhotoAssetAvailableCb);
5528 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5529 ret = OH_PhotoOutput_UnregisterPhotoAssetAvailableCallback(photoOutput, nullptr);
5530 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5531 }
5532 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5533 EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), CAMERA_OK);
5534 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5535 }
5536
5537 /*
5538 * Feature: Framework
5539 * Function: Test moving photo supported or not
5540 * SubFunction: NA
5541 * FunctionPoints: NA
5542 * EnvConditions: NA
5543 * CaseDescription: Test moving photo supported or not
5544 */
5545 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_071, TestSize.Level0)
5546 {
5547 Camera_CaptureSession* captureSession = nullptr;
5548 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5549 EXPECT_EQ(ret, CAMERA_OK);
5550 ASSERT_NE(captureSession, nullptr);
5551 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5552 EXPECT_EQ(ret, CAMERA_OK);
5553 ret = OH_CaptureSession_BeginConfig(captureSession);
5554 EXPECT_EQ(ret, CAMERA_OK);
5555 Camera_Input *cameraInput = nullptr;
5556 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5557 EXPECT_EQ(ret, CAMERA_OK);
5558 ASSERT_NE(&cameraInput, nullptr);
5559 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
5560 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
5561 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
5562 ASSERT_NE(photooutput, nullptr);
5563 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
5564 EXPECT_EQ(ret, CAMERA_OK);
5565 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5566 bool isSupported = false;
5567 ret = OH_PhotoOutput_IsMovingPhotoSupported(photooutput, &isSupported);
5568 EXPECT_EQ(ret, CAMERA_OK);
5569 if (isSupported == true) {
5570 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, true);
5571 EXPECT_EQ(ret, CAMERA_OK);
5572 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, false);
5573 EXPECT_EQ(ret, CAMERA_OK);
5574 } else {
5575 ret = OH_PhotoOutput_IsMovingPhotoSupported(nullptr, &isSupported);
5576 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5577 }
5578 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
5579 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5580 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5581 }
5582
5583 /*
5584 * Feature: Framework
5585 * Function: Test enable moving photo
5586 * SubFunction: NA
5587 * FunctionPoints: NA
5588 * EnvConditions: NA
5589 * CaseDescription: Test enable moving photo
5590 */
5591 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_072, TestSize.Level0)
5592 {
5593 Camera_CaptureSession* captureSession = nullptr;
5594 Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession);
5595 EXPECT_EQ(ret, CAMERA_OK);
5596 ASSERT_NE(captureSession, nullptr);
5597 ret = OH_CaptureSession_SetSessionMode(captureSession, NORMAL_PHOTO);
5598 EXPECT_EQ(ret, CAMERA_OK);
5599 ret = OH_CaptureSession_BeginConfig(captureSession);
5600 EXPECT_EQ(ret, CAMERA_OK);
5601 Camera_Input *cameraInput = nullptr;
5602 ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput);
5603 EXPECT_EQ(ret, CAMERA_OK);
5604 ASSERT_NE(&cameraInput, nullptr);
5605 EXPECT_EQ(OH_CameraInput_Open(cameraInput), CAMERA_OK);
5606 EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), CAMERA_OK);
5607 Camera_PhotoOutput *photooutput = CreatePhotoOutput();
5608 ASSERT_NE(photooutput, nullptr);
5609 ret = OH_CaptureSession_AddPhotoOutput(captureSession, photooutput);
5610 EXPECT_EQ(ret, CAMERA_OK);
5611 EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), CAMERA_OK);
5612 bool isSupported = false;
5613 ret = OH_PhotoOutput_IsMovingPhotoSupported(photooutput, &isSupported);
5614 EXPECT_EQ(ret, CAMERA_OK);
5615 if (isSupported == true) {
5616 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, true);
5617 EXPECT_EQ(ret, CAMERA_OK);
5618 ret = OH_PhotoOutput_EnableMovingPhoto(photooutput, false);
5619 EXPECT_EQ(ret, CAMERA_OK);
5620 ret = OH_PhotoOutput_EnableMovingPhoto(nullptr, true);
5621 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5622 }
5623 EXPECT_EQ(OH_PhotoOutput_Release(photooutput), CAMERA_OK);
5624 EXPECT_EQ(OH_CameraInput_Release(cameraInput), CAMERA_OK);
5625 EXPECT_EQ(OH_CaptureSession_Release(captureSession), CAMERA_OK);
5626 }
5627
5628 /*
5629 * Feature: Framework
5630 * Function: Test get main image in photo native
5631 * SubFunction: NA
5632 * FunctionPoints: NA
5633 * EnvConditions: NA
5634 * CaseDescription: Test get main image in photo native
5635 */
5636 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_073, TestSize.Level0)
5637 {
5638 OH_PhotoNative* photoNative = new OH_PhotoNative();
5639 OH_ImageNative* mainImage = nullptr;
5640 Camera_ErrorCode ret = OH_PhotoNative_GetMainImage(photoNative, &mainImage);
5641 EXPECT_EQ(ret, CAMERA_OK);
5642 ret = OH_PhotoNative_GetMainImage(nullptr, &mainImage);
5643 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5644 ret = OH_PhotoNative_GetMainImage(photoNative, nullptr);
5645 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5646 std::shared_ptr<OHOS::Media::NativeImage> mainImage_ = std::make_shared<OHOS::Media::NativeImage>(nullptr, nullptr);
5647 photoNative->SetMainImage(mainImage_);
5648 ret = OH_PhotoNative_GetMainImage(photoNative, &mainImage);
5649 EXPECT_EQ(ret, CAMERA_OK);
5650 ASSERT_NE(mainImage, nullptr);
5651 EXPECT_EQ(OH_PhotoNative_Release(photoNative), CAMERA_OK);
5652 }
5653
5654 /*
5655 * Feature: Framework
5656 * Function: Test release in photo native
5657 * SubFunction: NA
5658 * FunctionPoints: NA
5659 * EnvConditions: NA
5660 * CaseDescription: Test release in photo native
5661 */
5662 HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_074, TestSize.Level0)
5663 {
5664 OH_PhotoNative* photoNative = new OH_PhotoNative();
5665 OH_ImageNative* mainImage = nullptr;
5666 Camera_ErrorCode ret = OH_PhotoNative_GetMainImage(photoNative, &mainImage);
5667 EXPECT_EQ(ret, CAMERA_OK);
5668 ret = OH_PhotoNative_GetMainImage(nullptr, &mainImage);
5669 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5670 ret = OH_PhotoNative_GetMainImage(photoNative, nullptr);
5671 EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT);
5672 EXPECT_EQ(OH_PhotoNative_Release(photoNative), CAMERA_OK);
5673 EXPECT_EQ(OH_PhotoNative_Release(nullptr), CAMERA_INVALID_ARGUMENT);
5674 }
5675 } // CameraStandard
5676 } // OHOS