1 /*
2 * Copyright (c) 2023 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 <cstring>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <ui/rs_surface_node.h>
20
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23 #include "nweb_adapter_helper.h"
24 #include "syspara/parameters.h"
25 #include "token_setproc.h"
26
27 #define private public
28 #include "camera_device.h"
29 #include "camera_manager.h"
30 #include "camera_manager_adapter_impl.h"
31 #include "nweb_surface_adapter.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::CameraStandard;
36 using namespace OHOS::Rosen;
37 using namespace OHOS::Camera;
38
39 namespace OHOS::NWeb {
40 namespace {
41 sptr<SurfaceBuffer> g_surfaceBuffer = nullptr;
42 sptr<CameraManager> g_cameraManager = nullptr;
43 const uint32_t DEFAULT_WIDTH = 2560;
44 const uint32_t DEFAULT_HEIGHT = 1396;
45 } // namespace
46
47 class CameraAdapterImplTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 };
54
SetUpTestCase(void)55 void CameraAdapterImplTest::SetUpTestCase(void)
56 {
57 RSSurfaceNodeConfig config;
58 config.SurfaceNodeName = "webTestSurfaceName";
59 auto surfaceNode = RSSurfaceNode::Create(config, false);
60 EXPECT_NE(surfaceNode, nullptr);
61 sptr<Surface> surface = surfaceNode->GetSurface();
62 EXPECT_NE(surface, nullptr);
63 auto surfaceAdapter = NWebSurfaceAdapter::Instance();
64 g_surfaceBuffer = surfaceAdapter.RequestBuffer(surface, DEFAULT_WIDTH, DEFAULT_HEIGHT);
65 EXPECT_NE(g_surfaceBuffer, nullptr);
66
67 // set native token
68 uint64_t tokenId;
69 const char* perms[2];
70 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
71 perms[1] = "ohos.permission.CAMERA";
72 NativeTokenInfoParams infoInstance = {
73 .dcapsNum = 0,
74 .permsNum = 2,
75 .aclsNum = 0,
76 .dcaps = NULL,
77 .perms = perms,
78 .acls = NULL,
79 .processName = "native_camera_tdd",
80 .aplStr = "system_basic",
81 };
82 tokenId = GetAccessTokenId(&infoInstance);
83 SetSelfTokenID(tokenId);
84 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
85
86 g_cameraManager = CameraManager::GetInstance();
87 EXPECT_NE(g_cameraManager, nullptr);
88 }
89
TearDownTestCase(void)90 void CameraAdapterImplTest::TearDownTestCase(void) {}
91
SetUp(void)92 void CameraAdapterImplTest::SetUp(void) {}
93
TearDown(void)94 void CameraAdapterImplTest::TearDown(void) {}
95
96 class CameraBufferListenerAdapterMock : public CameraBufferListenerAdapter {
97 public:
CameraBufferListenerAdapterMock()98 CameraBufferListenerAdapterMock() {}
99 ~CameraBufferListenerAdapterMock() override = default;
100
OnBufferAvailable(std::shared_ptr<CameraSurfaceAdapter> surface,std::shared_ptr<CameraSurfaceBufferAdapter> buffer,std::shared_ptr<CameraRotationInfoAdapter> rotationInfo)101 void OnBufferAvailable(std::shared_ptr<CameraSurfaceAdapter> surface,
102 std::shared_ptr<CameraSurfaceBufferAdapter> buffer,
103 std::shared_ptr<CameraRotationInfoAdapter> rotationInfo) override
104 {}
105 };
106
107 class CameraStatusCallbackAdapterMock : public CameraStatusCallbackAdapter {
108 public:
CameraStatusCallbackAdapterMock()109 CameraStatusCallbackAdapterMock() {}
110 ~CameraStatusCallbackAdapterMock() override = default;
111
OnCameraStatusChanged(CameraStatusAdapter cameraStatusAdapter,std::string callBackDeviceId)112 void OnCameraStatusChanged(CameraStatusAdapter cameraStatusAdapter, std::string callBackDeviceId) override {}
113 };
114
115 class CameraManagerMock : public CameraManager {
116 public:
117 MOCK_METHOD0(CreateCaptureSession, sptr<CaptureSession>());
118 };
119
120 class VideoCaptureParamsAdapterMock : public VideoCaptureParamsAdapter {
121 public:
122 VideoCaptureParamsAdapterMock() = default;
123
GetWidth()124 uint32_t GetWidth() override
125 {
126 return width;
127 }
128
GetHeight()129 uint32_t GetHeight() override
130 {
131 return height;
132 }
133
GetFrameRate()134 float GetFrameRate() override
135 {
136 return frameRate;
137 }
138
GetPixelFormat()139 VideoPixelFormatAdapter GetPixelFormat() override
140 {
141 return pixelFormat;
142 }
143
GetEnableFaceDetection()144 bool GetEnableFaceDetection() override
145 {
146 return enableFaceDetection;
147 }
148
149 uint32_t width;
150 uint32_t height;
151 float frameRate;
152 VideoPixelFormatAdapter pixelFormat;
153 bool enableFaceDetection;
154 };
155
156 /**
157 * @tc.name: CameraAdapterImplTest_GetFileDescriptor_001
158 * @tc.desc: GetFileDescriptor.
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetFileDescriptor_001, TestSize.Level1)
163 {
164 auto adapterImpl = std::make_shared<CameraSurfaceBufferAdapterImpl>(g_surfaceBuffer);
165 EXPECT_NE(adapterImpl, nullptr);
166 int32_t result = adapterImpl->GetFileDescriptor();
167 EXPECT_NE(result, -1);
168 result = adapterImpl->GetWidth();
169 EXPECT_NE(result, -1);
170 result = adapterImpl->GetHeight();
171 EXPECT_NE(result, -1);
172 result = adapterImpl->GetStride();
173 EXPECT_NE(result, -1);
174 result = adapterImpl->GetFormat();
175 EXPECT_NE(result, -1);
176 uint32_t surfaceBufferSize = adapterImpl->GetSize();
177 EXPECT_NE(surfaceBufferSize, 0);
178 sptr<SurfaceBuffer> buffer = adapterImpl->GetBuffer();
179 EXPECT_NE(buffer, nullptr);
180 uint8_t* addBuffer = adapterImpl->GetBufferAddr();
181 EXPECT_NE(addBuffer, nullptr);
182 }
183
184 /**
185 * @tc.name: CameraAdapterImplTest_GetFileDescriptor_002
186 * @tc.desc: GetFileDescriptor.
187 * @tc.type: FUNC
188 * @tc.require:
189 */
190 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetFileDescriptor_002, TestSize.Level1)
191 {
192 auto adapterImpl = std::make_shared<CameraSurfaceBufferAdapterImpl>(nullptr);
193 EXPECT_NE(adapterImpl, nullptr);
194 int32_t result = adapterImpl->GetFileDescriptor();
195 EXPECT_EQ(result, -1);
196 result = adapterImpl->GetWidth();
197 EXPECT_EQ(result, -1);
198 result = adapterImpl->GetHeight();
199 EXPECT_EQ(result, -1);
200 result = adapterImpl->GetStride();
201 EXPECT_EQ(result, -1);
202 result = adapterImpl->GetFormat();
203 EXPECT_EQ(result, -1);
204 uint32_t surfaceBufferSize = adapterImpl->GetSize();
205 EXPECT_EQ(surfaceBufferSize, 0);
206 uint8_t* addBuffer = adapterImpl->GetBufferAddr();
207 EXPECT_EQ(addBuffer, nullptr);
208 }
209
210 /**
211 * @tc.name: CameraAdapterImplTest_CameraSurfaceListener_003
212 * @tc.desc: CameraSurfaceListener.
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraSurfaceListener_003, TestSize.Level1)
217 {
218 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
219 EXPECT_NE(surface, nullptr);
220 auto listenerAdapter = std::make_shared<CameraBufferListenerAdapterMock>();
221 EXPECT_NE(listenerAdapter, nullptr);
222 auto listener = std::make_shared<CameraSurfaceListener>(SurfaceType::PREVIEW, surface, listenerAdapter);
223 EXPECT_NE(listener, nullptr);
224 listener->OnBufferAvailable();
225
226 std::shared_ptr<CameraRotationInfoAdapter> info =
227 listener->GetRotationInfo(GraphicTransformType::GRAPHIC_ROTATE_NONE);
228 EXPECT_NE(info, nullptr);
229 EXPECT_FALSE(info->GetIsFlipX());
230 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_ROTATE_90);
231 EXPECT_FALSE(info->GetIsFlipX());
232 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_ROTATE_180);
233 EXPECT_FALSE(info->GetIsFlipX());
234 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_ROTATE_270);
235 EXPECT_FALSE(info->GetIsFlipX());
236 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_H);
237 EXPECT_FALSE(info->GetIsFlipX());
238 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_V);
239 EXPECT_TRUE(info->GetIsFlipX());
240 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_H_ROT90);
241 EXPECT_FALSE(info->GetIsFlipX());
242 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_V_ROT90);
243 EXPECT_TRUE(info->GetIsFlipX());
244 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_H_ROT180);
245 EXPECT_FALSE(info->GetIsFlipX());
246 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_V_ROT180);
247 EXPECT_TRUE(info->GetIsFlipX());
248 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_H_ROT270);
249 EXPECT_FALSE(info->GetIsFlipX());
250 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_FLIP_V_ROT270);
251 EXPECT_TRUE(info->GetIsFlipX());
252 info = listener->GetRotationInfo(GraphicTransformType::GRAPHIC_ROTATE_BUTT);
253 EXPECT_FALSE(info->GetIsFlipX());
254 listener->surface_ = nullptr;
255 listener->OnBufferAvailable();
256 }
257
258 /**
259 * @tc.name: CameraAdapterImplTest_GetFileDescriptor_004
260 * @tc.desc: GetFileDescriptor.
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetFileDescriptor_004, TestSize.Level1)
265 {
266 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
267 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
268 int32_t result = CameraManagerAdapterImpl::GetInstance().Create(callback);
269 EXPECT_EQ(result, 0);
270 result = CameraManagerAdapterImpl::GetInstance().Create(callback);
271 EXPECT_EQ(result, 0);
272 VideoTransportType type = adapter.GetCameraTransportType(ConnectionType::CAMERA_CONNECTION_BUILT_IN);
273 EXPECT_EQ(type, VideoTransportType::VIDEO_TRANS_TYPE_BUILD_IN);
274 type = adapter.GetCameraTransportType(static_cast<ConnectionType>(-1));
275 EXPECT_EQ(type, VideoTransportType::VIDEO_TRANS_TYPE_OTHER);
276 VideoFacingModeAdapter modeAdapter = adapter.GetCameraFacingMode(CameraPosition::CAMERA_POSITION_UNSPECIFIED);
277 EXPECT_EQ(modeAdapter, VideoFacingModeAdapter::FACING_NONE);
278 modeAdapter = adapter.GetCameraFacingMode(static_cast<CameraPosition>(-1));
279 EXPECT_EQ(modeAdapter, VideoFacingModeAdapter::FACING_NONE);
280 VideoPixelFormatAdapter formatAdapter =
281 adapter.TransToAdapterCameraFormat(CameraFormat::CAMERA_FORMAT_YCBCR_420_888);
282 EXPECT_EQ(formatAdapter, VideoPixelFormatAdapter::FORMAT_YCBCR_420_888);
283 formatAdapter = adapter.TransToAdapterCameraFormat(static_cast<CameraFormat>(0));
284 EXPECT_EQ(formatAdapter, VideoPixelFormatAdapter::FORMAT_UNKNOWN);
285 CameraFormat format = adapter.TransToOriCameraFormat(VideoPixelFormatAdapter::FORMAT_YCBCR_420_888);
286 EXPECT_EQ(format, CameraFormat::CAMERA_FORMAT_YCBCR_420_888);
287 format = adapter.TransToOriCameraFormat(static_cast<VideoPixelFormatAdapter>(-1));
288 EXPECT_EQ(format, CameraFormat::CAMERA_FORMAT_INVALID);
289 ExposureModeAdapter exposure = adapter.GetAdapterExposureMode(ExposureMode::EXPOSURE_MODE_LOCKED);
290 EXPECT_EQ(exposure, ExposureModeAdapter::EXPOSURE_MODE_LOCKED);
291 exposure = adapter.GetAdapterExposureMode(static_cast<ExposureMode>(DEFAULT_WIDTH));
292 EXPECT_EQ(exposure, ExposureModeAdapter::EXPOSURE_MODE_UNSUPPORTED);
293 }
294
295 /**
296 * @tc.name: CameraAdapterImplTest_GetAdapterFocusMode_005
297 * @tc.desc: GetAdapterFocusMode.
298 * @tc.type: FUNC
299 * @tc.require:
300 */
301 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetAdapterFocusMode_005, TestSize.Level1)
302 {
303 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
304 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
305 int32_t result = CameraManagerAdapterImpl::GetInstance().Create(callback);
306 EXPECT_EQ(result, 0);
307 FocusMode mode = adapter.GetOriFocusMode(FocusModeAdapter::FOCUS_MODE_CONTINUOUS_AUTO);
308 EXPECT_EQ(mode, FocusMode::FOCUS_MODE_CONTINUOUS_AUTO);
309 mode = adapter.GetOriFocusMode(static_cast<FocusModeAdapter>(-1));
310 EXPECT_EQ(mode, FocusMode::FOCUS_MODE_MANUAL);
311 FlashMode flashMode = adapter.GetOriFlashMode(FlashModeAdapter::FLASH_MODE_OPEN);
312 EXPECT_EQ(flashMode, FlashMode::FLASH_MODE_OPEN);
313 flashMode = adapter.GetOriFlashMode(static_cast<FlashModeAdapter>(-1));
314 EXPECT_EQ(flashMode, FlashMode::FLASH_MODE_CLOSE);
315 FocusModeAdapter focusMode = adapter.GetAdapterFocusMode(FocusMode::FOCUS_MODE_CONTINUOUS_AUTO);
316 EXPECT_EQ(focusMode, FocusModeAdapter::FOCUS_MODE_CONTINUOUS_AUTO);
317 focusMode = adapter.GetAdapterFocusMode(static_cast<FocusMode>(-1));
318 EXPECT_EQ(focusMode, FocusModeAdapter::FOCUS_MODE_MANUAL);
319 std::string errnoTypeString;
320 CameraManagerAdapterImpl::GetInstance().ErrorTypeToString(
321 static_cast<CameraErrorType>(-1), errnoTypeString);
322 std::string displayName = adapter.GetCameraDisplayName("Camera01", CAMERA_POSITION_FRONT);
323 EXPECT_EQ(displayName, "Camera01, facing front");
324 displayName = adapter.GetCameraDisplayName("Camera02", CAMERA_POSITION_BACK);
325 EXPECT_EQ(displayName, "Camera02, facing back");
326 displayName = adapter.GetCameraDisplayName("Camera03", CAMERA_POSITION_FOLD_INNER);
327 EXPECT_EQ(displayName, "Camera03, facing fold inner");
328 displayName = adapter.GetCameraDisplayName("Camera04", static_cast<CameraPosition>(999));
329 EXPECT_EQ(displayName, "Camera04");
330 }
331
332 /**
333 * @tc.name: CameraAdapterImplTest_GetOriFocusMode_006
334 * @tc.desc: GetOriFocusMode.
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetOriFocusMode_006, TestSize.Level1)
339 {
340 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
341 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
342 int32_t result = adapter.Create(callback);
343 std::vector<std::shared_ptr<VideoDeviceDescriptorAdapter>> devicesDiscriptor = adapter.GetDevicesInfo();
344 std::shared_ptr<CameraMetadata> data = std::make_shared<CameraMetadata>(0, 0);
345 dmDeviceInfo tempDmDeviceInfo;
346 std::string deviceId = "0";
347 result = adapter.InitCameraInput(deviceId);
348 EXPECT_NE(result, 0);
349 sptr<ICameraDeviceService> deviceObj = nullptr;
350 std::vector<sptr<CameraDevice>> cameras = g_cameraManager->GetSupportedCameras();
351 sptr<CameraInput> cameraInput = g_cameraManager->CreateCameraInput(cameras[0]);
352 adapter.cameraInput_ = cameraInput;
353 result = adapter.InitCameraInput(deviceId);
354 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
355 EXPECT_NE(captureParams, nullptr);
356 captureParams->width = 1;
357 captureParams->height = 1;
358 captureParams->frameRate = 1;
359 captureParams->pixelFormat = VideoPixelFormatAdapter::FORMAT_RGBA_8888;
360 captureParams->enableFaceDetection = true;
361 std::shared_ptr<CameraBufferListenerAdapter> listener = std::make_shared<CameraBufferListenerAdapterMock>();
362 adapter.inputInitedFlag_ = true;
363 result = adapter.InitPreviewOutput(captureParams, listener);
364 EXPECT_EQ(result, 0);
365 result = adapter.CreateAndStartSession();
366 EXPECT_NE(result, 0);
367 result = adapter.RestartSession();
368 EXPECT_EQ(result, 0);
369 adapter.status_ = CameraStatusAdapter::UNAVAILABLE;
370 result = adapter.CreateAndStartSession();
371 EXPECT_NE(result, 0);
372 result = adapter.StopSession(CameraStopType::NORMAL);
373 EXPECT_EQ(result, 0);
374 result = adapter.StopSession(CameraStopType::TO_BACK);
375 EXPECT_EQ(result, 0);
376 result = adapter.ReleaseSession();
377 EXPECT_EQ(result, 0);
378 result = adapter.ReleaseSessionResource("test");
379 EXPECT_EQ(result, 0);
380 result = adapter.ReleaseSessionResource(deviceId);
381 EXPECT_EQ(result, 0);
382 adapter.ReleaseCameraManger();
383 }
384
385 /**
386 * @tc.name: CameraAdapterImplTest_TransToAdapterExposureModes_007
387 * @tc.desc: TransToAdapterExposureModes.
388 * @tc.type: FUNC
389 * @tc.require:
390 */
391 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_TransToAdapterExposureModes_007, TestSize.Level1)
392 {
393 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
394 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
395 int32_t result = adapter.Create(callback);
396 EXPECT_EQ(result, 0);
397 std::vector<ExposureMode> exposureModes;
398 exposureModes.push_back(EXPOSURE_MODE_UNSUPPORTED);
399 exposureModes.push_back(EXPOSURE_MODE_LOCKED);
400 exposureModes.push_back(EXPOSURE_MODE_AUTO);
401 exposureModes.push_back(EXPOSURE_MODE_CONTINUOUS_AUTO);
402 std::vector<ExposureModeAdapter> exposureModesAdapter;
403 result = adapter.TransToAdapterExposureModes(exposureModes, exposureModesAdapter);
404 EXPECT_EQ(result, 0);
405 std::vector<std::shared_ptr<VideoDeviceDescriptorAdapter>> devicesDiscriptor = adapter.GetDevicesInfo();
406 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
407 EXPECT_NE(captureParams, nullptr);
408 captureParams->width = 1;
409 captureParams->height = 1;
410 captureParams->frameRate = 1;
411 captureParams->pixelFormat = VideoPixelFormatAdapter::FORMAT_RGBA_8888;
412 captureParams->enableFaceDetection = true;
413 std::shared_ptr<CameraBufferListenerAdapter> listener = std::make_shared<CameraBufferListenerAdapterMock>();
414 adapter.inputInitedFlag_ = true;
415 result = adapter.InitPreviewOutput(captureParams, listener);
416 EXPECT_EQ(result, 0);
417 result = adapter.CreateAndStartSession();
418 EXPECT_NE(result, 0);
419 sptr<CaptureSession> captureSession = g_cameraManager->CreateCaptureSession();
420 EXPECT_NE(captureSession, nullptr);
421 adapter.captureSession_ = captureSession;
422 result = adapter.GetExposureModes(exposureModesAdapter);
423 EXPECT_NE(result, 0);
424 ExposureModeAdapter exposureModeAdapter;
425 result = adapter.GetCurrentExposureMode(exposureModeAdapter);
426 EXPECT_EQ(result, 0);
427 std::shared_ptr<VideoCaptureRangeAdapter> rangeVal = adapter.GetExposureCompensation();
428 EXPECT_NE(rangeVal, nullptr);
429 rangeVal = nullptr;
430 rangeVal = adapter.GetCaptionRangeById(RangeIDAdapter::RANGE_ID_EXP_COMPENSATION);
431 EXPECT_NE(rangeVal, nullptr);
432 rangeVal = adapter.GetCaptionRangeById(static_cast<RangeIDAdapter>(1));
433 bool isMode = adapter.IsFocusModeSupported(FocusModeAdapter::FOCUS_MODE_CONTINUOUS_AUTO);
434 EXPECT_FALSE(isMode);
435 adapter.GetCurrentFocusMode();
436 isMode = adapter.IsFlashModeSupported(FlashModeAdapter::FLASH_MODE_OPEN);
437 EXPECT_FALSE(isMode);
438 }
439
440 /**
441 * @tc.name: CameraAdapterImplTest_GetOriFocusMode_008
442 * @tc.desc: GetOriFocusMode.
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetOriFocusMode_008, TestSize.Level1)
447 {
448 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
449 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
450 int32_t result = adapter.Create(callback);
451 EXPECT_EQ(result, 0);
452 adapter.isForegound_ = true;
453 adapter.isCapturing_ = true;
454 result = adapter.RestartSession();
455 EXPECT_NE(result, 0);
456 result = adapter.RestartSession();
457 EXPECT_NE(result, 0);
458 adapter.cameraManager_ = nullptr;
459 result = adapter.RestartSession();
460 EXPECT_NE(result, 0);
461 std::vector<std::shared_ptr<VideoDeviceDescriptorAdapter>> devicesDiscriptor = adapter.GetDevicesInfo();
462 EXPECT_TRUE(devicesDiscriptor.empty());
463 std::string deviceId = "0";
464 result = adapter.InitCameraInput(deviceId);
465 EXPECT_NE(result, 0);
466 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
467 EXPECT_NE(captureParams, nullptr);
468 result = adapter.InitPreviewOutput(captureParams, nullptr);
469 EXPECT_NE(result, 0);
470 adapter.status_ = CameraStatusAdapter::AVAILABLE;
471 adapter.isCapturing_ = false;
472 result = adapter.RestartSession();
473 EXPECT_EQ(result, 0);
474 adapter.status_ = CameraStatusAdapter::UNAVAILABLE;
475 result = adapter.RestartSession();
476 EXPECT_EQ(result, 0);
477 result = adapter.ReleaseSession();
478 EXPECT_EQ(result, 0);
479 std::vector<ExposureModeAdapter> exposureModesAdapter;
480 result = adapter.GetExposureModes(exposureModesAdapter);
481 EXPECT_NE(result, 0);
482 ExposureModeAdapter exposureModeAdapter;
483 result = adapter.GetCurrentExposureMode(exposureModeAdapter);
484 EXPECT_NE(result, 0);
485 std::shared_ptr<VideoCaptureRangeAdapter> rangeVal = adapter.GetExposureCompensation();
486 EXPECT_EQ(rangeVal, nullptr);
487 rangeVal = nullptr;
488 rangeVal = adapter.GetCaptionRangeById(RangeIDAdapter::RANGE_ID_EXP_COMPENSATION);
489 EXPECT_EQ(rangeVal, nullptr);
490 bool isMode = adapter.IsFocusModeSupported(FocusModeAdapter::FOCUS_MODE_CONTINUOUS_AUTO);
491 EXPECT_FALSE(isMode);
492 FocusModeAdapter focusMode = adapter.GetCurrentFocusMode();
493 EXPECT_EQ(focusMode, FocusModeAdapter::FOCUS_MODE_MANUAL);
494 isMode = adapter.IsFlashModeSupported(FlashModeAdapter::FLASH_MODE_OPEN);
495 EXPECT_FALSE(isMode);
496 }
497
498 /**
499 * @tc.name: CameraAdapterImplTest_CameraSurfaceAdapterImpl_009
500 * @tc.desc: CameraSurfaceAdapterImpl.
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraSurfaceAdapterImpl_009, TestSize.Level1)
505 {
506 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
507 EXPECT_NE(surface, nullptr);
508 auto listener = std::make_shared<CameraSurfaceAdapterImpl>(surface);
509 EXPECT_NE(listener, nullptr);
510 listener->ReleaseBuffer(nullptr, -1);
511 int32_t result = listener->ReleaseBuffer(nullptr, -1);
512 EXPECT_EQ(result, -1);
513 listener->cSurface_ = nullptr;
514 result = listener->ReleaseBuffer(nullptr, -1);
515 EXPECT_EQ(result, -1);
516 }
517
518 /**
519 * @tc.name: CameraAdapterImplTest_InitCameraInput_010
520 * @tc.desc: GetOriFocusMode.
521 * @tc.type: FUNC
522 * @tc.require:
523 */
524 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_InitCameraInput_010, TestSize.Level1)
525 {
526 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
527 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
528 int32_t result = adapter.Create(callback);
529 EXPECT_EQ(result, 0);
530 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
531 EXPECT_NE(captureParams, nullptr);
532 captureParams->width = 1;
533 captureParams->height = 1;
534 captureParams->frameRate = 1;
535 captureParams->pixelFormat = VideoPixelFormatAdapter::FORMAT_RGBA_8888;
536 captureParams->enableFaceDetection = true;
537 auto listenerAdapter = std::make_shared<CameraBufferListenerAdapterMock>();
538 EXPECT_NE(listenerAdapter, nullptr);
539 std::string deviceId = "0";
540 adapter.status_ = CameraStatusAdapter::UNAVAILABLE;
541 result = adapter.InitCameraInput(deviceId);
542 EXPECT_NE(result, 0);
543 adapter.isCapturing_ = true;
544 bool isExist = adapter.IsExistCaptureTask();
545 EXPECT_TRUE(isExist);
546 result = adapter.StartStream(deviceId, nullptr, nullptr);
547 EXPECT_NE(result, 0);
548 result = adapter.StartStream(deviceId, captureParams, nullptr);
549 EXPECT_NE(result, 0);
550 adapter.status_ = CameraStatusAdapter::AVAILABLE;
551 adapter.inputInitedFlag_ = true;
552 result = adapter.InitCameraInput(deviceId);
553 EXPECT_NE(result, 0);
554 adapter.inputInitedFlag_ = false;
555 result = adapter.InitCameraInput(deviceId);
556 EXPECT_NE(result, 0);
557 adapter.cameraManager_ = nullptr;
558 result = adapter.InitCameraInput(deviceId);
559 EXPECT_NE(result, 0);
560
561 std::shared_ptr<VideoCaptureRangeAdapter> rangeVal =
562 adapter.GetCaptionRangeById(RangeIDAdapter::RANGE_ID_EXP_COMPENSATION);
563 EXPECT_EQ(rangeVal, nullptr);
564 adapter.inputInitedFlag_ = true;
565 result = adapter.InitPreviewOutput(captureParams, nullptr);
566 EXPECT_NE(result, 0);
567 isExist = adapter.IsExistCaptureTask();
568 EXPECT_FALSE(isExist);
569 result = adapter.StartStream(deviceId, captureParams, listenerAdapter);
570 EXPECT_NE(result, 0);
571 }
572
573 /**
574 * @tc.name: CameraAdapterImplTest_CameraManagerAdapterCallback_011
575 * @tc.desc: CameraManagerAdapterCallback.
576 * @tc.type: FUNC
577 * @tc.require:
578 */
579 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraManagerAdapterCallback_011, TestSize.Level1)
580 {
581 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
582 EXPECT_NE(callback, nullptr);
583 CameraManagerAdapterCallback adapter(callback);
584 CameraStatusAdapter status = adapter.GetAdapterCameraStatus(CameraStatus::CAMERA_STATUS_APPEAR);
585 EXPECT_EQ(status, CameraStatusAdapter::APPEAR);
586 status = adapter.GetAdapterCameraStatus(static_cast<CameraStatus>(-1));
587 EXPECT_EQ(status, CameraStatusAdapter::APPEAR);
588 CameraStatusInfo cameraStatusInfo = {
589 .cameraInfo = nullptr, .cameraDevice = nullptr, .cameraStatus = CameraStatus::CAMERA_STATUS_APPEAR
590 };
591 adapter.OnCameraStatusChanged(cameraStatusInfo);
592 cameraStatusInfo.cameraStatus = CameraStatus::CAMERA_STATUS_DISAPPEAR;
593 adapter.OnCameraStatusChanged(cameraStatusInfo);
594 cameraStatusInfo.cameraStatus = CameraStatus::CAMERA_STATUS_AVAILABLE;
595 adapter.OnCameraStatusChanged(cameraStatusInfo);
596 cameraStatusInfo.cameraStatus = CameraStatus::CAMERA_STATUS_UNAVAILABLE;
597 adapter.OnCameraStatusChanged(cameraStatusInfo);
598 cameraStatusInfo.cameraStatus = static_cast<CameraStatus>(-1);
599 adapter.OnCameraStatusChanged(cameraStatusInfo);
600 adapter.statusCallback_ = nullptr;
601 adapter.OnCameraStatusChanged(cameraStatusInfo);
602 }
603
604 /**
605 * @tc.name: CameraAdapterImplTest_CameraStatus_012
606 * @tc.desc: CameraManagerAdapterCallback.
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraStatus_012, TestSize.Level1)
611 {
612 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
613 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
614 CameraStatusAdapter status = adapter.GetCameraStatus();
615 EXPECT_EQ(status, CameraStatusAdapter::AVAILABLE);
616 adapter.SetCameraStatus(status);
617 }
618
619 } // namespace OHOS::NWeb
620