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 }
323
324 /**
325 * @tc.name: CameraAdapterImplTest_GetOriFocusMode_006
326 * @tc.desc: GetOriFocusMode.
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetOriFocusMode_006, TestSize.Level1)
331 {
332 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
333 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
334 int32_t result = adapter.Create(callback);
335 std::vector<std::shared_ptr<VideoDeviceDescriptorAdapter>> devicesDiscriptor = adapter.GetDevicesInfo();
336 std::shared_ptr<CameraMetadata> data = std::make_shared<CameraMetadata>(0, 0);
337 dmDeviceInfo tempDmDeviceInfo;
338 std::string deviceId = "0";
339 result = adapter.InitCameraInput(deviceId);
340 EXPECT_NE(result, 0);
341 sptr<ICameraDeviceService> deviceObj = nullptr;
342 std::vector<sptr<CameraDevice>> cameras = g_cameraManager->GetSupportedCameras();
343 sptr<CameraInput> cameraInput = g_cameraManager->CreateCameraInput(cameras[0]);
344 adapter.cameraInput_ = cameraInput;
345 result = adapter.InitCameraInput(deviceId);
346 EXPECT_EQ(result, 0);
347 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
348 EXPECT_NE(captureParams, nullptr);
349 captureParams->width = 1;
350 captureParams->height = 1;
351 captureParams->frameRate = 1;
352 captureParams->pixelFormat = VideoPixelFormatAdapter::FORMAT_RGBA_8888;
353 captureParams->enableFaceDetection = true;
354 std::shared_ptr<CameraBufferListenerAdapter> listener = std::make_shared<CameraBufferListenerAdapterMock>();
355 adapter.inputInitedFlag_ = true;
356 result = adapter.InitPreviewOutput(captureParams, listener);
357 EXPECT_EQ(result, 0);
358 result = adapter.CreateAndStartSession();
359 EXPECT_NE(result, 0);
360 result = adapter.RestartSession();
361 EXPECT_EQ(result, 0);
362 adapter.status_ = CameraStatusAdapter::UNAVAILABLE;
363 result = adapter.CreateAndStartSession();
364 EXPECT_NE(result, 0);
365 result = adapter.StopSession(CameraStopType::NORMAL);
366 EXPECT_EQ(result, 0);
367 result = adapter.StopSession(CameraStopType::TO_BACK);
368 EXPECT_EQ(result, 0);
369 result = adapter.ReleaseSession();
370 EXPECT_EQ(result, 0);
371 result = adapter.ReleaseSessionResource("test");
372 EXPECT_EQ(result, 0);
373 result = adapter.ReleaseSessionResource(deviceId);
374 EXPECT_EQ(result, 0);
375 adapter.ReleaseCameraManger();
376 }
377
378 /**
379 * @tc.name: CameraAdapterImplTest_TransToAdapterExposureModes_007
380 * @tc.desc: TransToAdapterExposureModes.
381 * @tc.type: FUNC
382 * @tc.require:
383 */
384 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_TransToAdapterExposureModes_007, TestSize.Level1)
385 {
386 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
387 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
388 int32_t result = adapter.Create(callback);
389 EXPECT_EQ(result, 0);
390 std::vector<ExposureMode> exposureModes;
391 exposureModes.push_back(EXPOSURE_MODE_UNSUPPORTED);
392 exposureModes.push_back(EXPOSURE_MODE_LOCKED);
393 exposureModes.push_back(EXPOSURE_MODE_AUTO);
394 exposureModes.push_back(EXPOSURE_MODE_CONTINUOUS_AUTO);
395 std::vector<ExposureModeAdapter> exposureModesAdapter;
396 result = adapter.TransToAdapterExposureModes(exposureModes, exposureModesAdapter);
397 EXPECT_EQ(result, 0);
398 std::vector<std::shared_ptr<VideoDeviceDescriptorAdapter>> devicesDiscriptor = adapter.GetDevicesInfo();
399 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
400 EXPECT_NE(captureParams, nullptr);
401 captureParams->width = 1;
402 captureParams->height = 1;
403 captureParams->frameRate = 1;
404 captureParams->pixelFormat = VideoPixelFormatAdapter::FORMAT_RGBA_8888;
405 captureParams->enableFaceDetection = true;
406 std::shared_ptr<CameraBufferListenerAdapter> listener = std::make_shared<CameraBufferListenerAdapterMock>();
407 adapter.inputInitedFlag_ = true;
408 result = adapter.InitPreviewOutput(captureParams, listener);
409 EXPECT_EQ(result, 0);
410 result = adapter.CreateAndStartSession();
411 EXPECT_NE(result, 0);
412 sptr<CaptureSession> captureSession = g_cameraManager->CreateCaptureSession();
413 EXPECT_NE(captureSession, nullptr);
414 adapter.captureSession_ = captureSession;
415 result = adapter.GetExposureModes(exposureModesAdapter);
416 EXPECT_NE(result, 0);
417 ExposureModeAdapter exposureModeAdapter;
418 result = adapter.GetCurrentExposureMode(exposureModeAdapter);
419 EXPECT_EQ(result, 0);
420 std::shared_ptr<VideoCaptureRangeAdapter> rangeVal = adapter.GetExposureCompensation();
421 EXPECT_NE(rangeVal, nullptr);
422 rangeVal = nullptr;
423 rangeVal = adapter.GetCaptionRangeById(RangeIDAdapter::RANGE_ID_EXP_COMPENSATION);
424 EXPECT_NE(rangeVal, nullptr);
425 rangeVal = adapter.GetCaptionRangeById(static_cast<RangeIDAdapter>(1));
426 bool isMode = adapter.IsFocusModeSupported(FocusModeAdapter::FOCUS_MODE_CONTINUOUS_AUTO);
427 EXPECT_FALSE(isMode);
428 adapter.GetCurrentFocusMode();
429 isMode = adapter.IsFlashModeSupported(FlashModeAdapter::FLASH_MODE_OPEN);
430 EXPECT_FALSE(isMode);
431 }
432
433 /**
434 * @tc.name: CameraAdapterImplTest_GetOriFocusMode_008
435 * @tc.desc: GetOriFocusMode.
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_GetOriFocusMode_008, TestSize.Level1)
440 {
441 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
442 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
443 int32_t result = adapter.Create(callback);
444 EXPECT_EQ(result, 0);
445 adapter.isForegound_ = true;
446 adapter.isCapturing_ = true;
447 result = adapter.RestartSession();
448 EXPECT_NE(result, 0);
449 result = adapter.RestartSession();
450 EXPECT_NE(result, 0);
451 adapter.cameraManager_ = nullptr;
452 result = adapter.RestartSession();
453 EXPECT_NE(result, 0);
454 std::vector<std::shared_ptr<VideoDeviceDescriptorAdapter>> devicesDiscriptor = adapter.GetDevicesInfo();
455 EXPECT_TRUE(devicesDiscriptor.empty());
456 std::string deviceId = "0";
457 result = adapter.InitCameraInput(deviceId);
458 EXPECT_NE(result, 0);
459 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
460 EXPECT_NE(captureParams, nullptr);
461 result = adapter.InitPreviewOutput(captureParams, nullptr);
462 EXPECT_NE(result, 0);
463 adapter.status_ = CameraStatusAdapter::AVAILABLE;
464 adapter.isCapturing_ = false;
465 result = adapter.RestartSession();
466 EXPECT_EQ(result, 0);
467 adapter.status_ = CameraStatusAdapter::UNAVAILABLE;
468 result = adapter.RestartSession();
469 EXPECT_EQ(result, 0);
470 result = adapter.ReleaseSession();
471 EXPECT_EQ(result, 0);
472 std::vector<ExposureModeAdapter> exposureModesAdapter;
473 result = adapter.GetExposureModes(exposureModesAdapter);
474 EXPECT_NE(result, 0);
475 ExposureModeAdapter exposureModeAdapter;
476 result = adapter.GetCurrentExposureMode(exposureModeAdapter);
477 EXPECT_NE(result, 0);
478 std::shared_ptr<VideoCaptureRangeAdapter> rangeVal = adapter.GetExposureCompensation();
479 EXPECT_EQ(rangeVal, nullptr);
480 rangeVal = nullptr;
481 rangeVal = adapter.GetCaptionRangeById(RangeIDAdapter::RANGE_ID_EXP_COMPENSATION);
482 EXPECT_EQ(rangeVal, nullptr);
483 bool isMode = adapter.IsFocusModeSupported(FocusModeAdapter::FOCUS_MODE_CONTINUOUS_AUTO);
484 EXPECT_FALSE(isMode);
485 FocusModeAdapter focusMode = adapter.GetCurrentFocusMode();
486 EXPECT_EQ(focusMode, FocusModeAdapter::FOCUS_MODE_MANUAL);
487 isMode = adapter.IsFlashModeSupported(FlashModeAdapter::FLASH_MODE_OPEN);
488 EXPECT_FALSE(isMode);
489 }
490
491 /**
492 * @tc.name: CameraAdapterImplTest_CameraSurfaceAdapterImpl_009
493 * @tc.desc: CameraSurfaceAdapterImpl.
494 * @tc.type: FUNC
495 * @tc.require:
496 */
497 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraSurfaceAdapterImpl_009, TestSize.Level1)
498 {
499 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
500 EXPECT_NE(surface, nullptr);
501 auto listener = std::make_shared<CameraSurfaceAdapterImpl>(surface);
502 EXPECT_NE(listener, nullptr);
503 listener->ReleaseBuffer(nullptr, -1);
504 int32_t result = listener->ReleaseBuffer(nullptr, -1);
505 EXPECT_EQ(result, -1);
506 listener->cSurface_ = nullptr;
507 result = listener->ReleaseBuffer(nullptr, -1);
508 EXPECT_EQ(result, -1);
509 }
510
511 /**
512 * @tc.name: CameraAdapterImplTest_InitCameraInput_010
513 * @tc.desc: GetOriFocusMode.
514 * @tc.type: FUNC
515 * @tc.require:
516 */
517 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_InitCameraInput_010, TestSize.Level1)
518 {
519 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
520 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
521 int32_t result = adapter.Create(callback);
522 EXPECT_EQ(result, 0);
523 std::shared_ptr<VideoCaptureParamsAdapterMock> captureParams = std::make_shared<VideoCaptureParamsAdapterMock>();
524 EXPECT_NE(captureParams, nullptr);
525 captureParams->width = 1;
526 captureParams->height = 1;
527 captureParams->frameRate = 1;
528 captureParams->pixelFormat = VideoPixelFormatAdapter::FORMAT_RGBA_8888;
529 captureParams->enableFaceDetection = true;
530 auto listenerAdapter = std::make_shared<CameraBufferListenerAdapterMock>();
531 EXPECT_NE(listenerAdapter, nullptr);
532 std::string deviceId = "0";
533 adapter.status_ = CameraStatusAdapter::UNAVAILABLE;
534 result = adapter.InitCameraInput(deviceId);
535 EXPECT_NE(result, 0);
536 adapter.isCapturing_ = true;
537 bool isExist = adapter.IsExistCaptureTask();
538 EXPECT_TRUE(isExist);
539 result = adapter.StartStream(deviceId, nullptr, nullptr);
540 EXPECT_NE(result, 0);
541 result = adapter.StartStream(deviceId, captureParams, nullptr);
542 EXPECT_NE(result, 0);
543 adapter.status_ = CameraStatusAdapter::AVAILABLE;
544 adapter.inputInitedFlag_ = true;
545 result = adapter.InitCameraInput(deviceId);
546 EXPECT_NE(result, 0);
547 adapter.inputInitedFlag_ = false;
548 result = adapter.InitCameraInput(deviceId);
549 EXPECT_NE(result, 0);
550 adapter.cameraManager_ = nullptr;
551 result = adapter.InitCameraInput(deviceId);
552 EXPECT_NE(result, 0);
553
554 std::shared_ptr<VideoCaptureRangeAdapter> rangeVal =
555 adapter.GetCaptionRangeById(RangeIDAdapter::RANGE_ID_EXP_COMPENSATION);
556 EXPECT_EQ(rangeVal, nullptr);
557 adapter.inputInitedFlag_ = true;
558 result = adapter.InitPreviewOutput(captureParams, nullptr);
559 EXPECT_NE(result, 0);
560 isExist = adapter.IsExistCaptureTask();
561 EXPECT_FALSE(isExist);
562 result = adapter.StartStream(deviceId, captureParams, listenerAdapter);
563 EXPECT_NE(result, 0);
564 }
565
566 /**
567 * @tc.name: CameraAdapterImplTest_CameraManagerAdapterCallback_011
568 * @tc.desc: CameraManagerAdapterCallback.
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraManagerAdapterCallback_011, TestSize.Level1)
573 {
574 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
575 EXPECT_NE(callback, nullptr);
576 CameraManagerAdapterCallback adapter(callback);
577 CameraStatusAdapter status = adapter.GetAdapterCameraStatus(CameraStatus::CAMERA_STATUS_APPEAR);
578 EXPECT_EQ(status, CameraStatusAdapter::APPEAR);
579 status = adapter.GetAdapterCameraStatus(static_cast<CameraStatus>(-1));
580 EXPECT_EQ(status, CameraStatusAdapter::APPEAR);
581 CameraStatusInfo cameraStatusInfo = {
582 .cameraInfo = nullptr, .cameraDevice = nullptr, .cameraStatus = CameraStatus::CAMERA_STATUS_APPEAR
583 };
584 adapter.OnCameraStatusChanged(cameraStatusInfo);
585 cameraStatusInfo.cameraStatus = CameraStatus::CAMERA_STATUS_DISAPPEAR;
586 adapter.OnCameraStatusChanged(cameraStatusInfo);
587 cameraStatusInfo.cameraStatus = CameraStatus::CAMERA_STATUS_AVAILABLE;
588 adapter.OnCameraStatusChanged(cameraStatusInfo);
589 cameraStatusInfo.cameraStatus = CameraStatus::CAMERA_STATUS_UNAVAILABLE;
590 adapter.OnCameraStatusChanged(cameraStatusInfo);
591 cameraStatusInfo.cameraStatus = static_cast<CameraStatus>(-1);
592 adapter.OnCameraStatusChanged(cameraStatusInfo);
593 adapter.statusCallback_ = nullptr;
594 adapter.OnCameraStatusChanged(cameraStatusInfo);
595 }
596
597 /**
598 * @tc.name: CameraAdapterImplTest_CameraStatus_012
599 * @tc.desc: CameraManagerAdapterCallback.
600 * @tc.type: FUNC
601 * @tc.require:
602 */
603 HWTEST_F(CameraAdapterImplTest, CameraAdapterImplTest_CameraStatus_012, TestSize.Level1)
604 {
605 auto callback = std::make_shared<CameraStatusCallbackAdapterMock>();
606 CameraManagerAdapterImpl& adapter = CameraManagerAdapterImpl::GetInstance();
607 CameraStatusAdapter status = adapter.GetCameraStatus();
608 EXPECT_EQ(status, CameraStatusAdapter::AVAILABLE);
609 adapter.SetCameraStatus(status);
610 }
611
612 } // namespace OHOS::NWeb
613