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