• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_framework_moduletest.h"
17 #include <cinttypes>
18 #include "input/camera_input.h"
19 #include "input/camera_manager.h"
20 #include "camera_log.h"
21 #include "surface.h"
22 #include "test_common.h"
23 
24 #include "ipc_skeleton.h"
25 #include "access_token.h"
26 #include "hap_token_info.h"
27 #include "accesstoken_kit.h"
28 #include "token_setproc.h"
29 #include "camera_util.h"
30 #include "nativetoken_kit.h"
31 
32 using namespace testing::ext;
33 
34 namespace OHOS {
35 namespace CameraStandard {
36 namespace {
37     enum class CAM_PHOTO_EVENTS {
38         CAM_PHOTO_CAPTURE_START = 0,
39         CAM_PHOTO_CAPTURE_END,
40         CAM_PHOTO_CAPTURE_ERR,
41         CAM_PHOTO_FRAME_SHUTTER,
42         CAM_PHOTO_MAX_EVENT
43     };
44 
45     enum class CAM_PREVIEW_EVENTS {
46         CAM_PREVIEW_FRAME_START = 0,
47         CAM_PREVIEW_FRAME_END,
48         CAM_PREVIEW_FRAME_ERR,
49         CAM_PREVIEW_MAX_EVENT
50     };
51 
52     enum class CAM_VIDEO_EVENTS {
53         CAM_VIDEO_FRAME_START = 0,
54         CAM_VIDEO_FRAME_END,
55         CAM_VIDEO_FRAME_ERR,
56         CAM_VIDEO_MAX_EVENT
57     };
58 
59     const int32_t WAIT_TIME_AFTER_CAPTURE = 1;
60     const int32_t WAIT_TIME_AFTER_START = 2;
61     const int32_t WAIT_TIME_BEFORE_STOP = 1;
62 
63     bool g_camInputOnError = false;
64     bool g_sessionclosed = false;
65     int32_t g_videoFd = -1;
66     std::bitset<static_cast<int>(CAM_PHOTO_EVENTS::CAM_PHOTO_MAX_EVENT)> g_photoEvents;
67     std::bitset<static_cast<unsigned int>(CAM_PREVIEW_EVENTS::CAM_PREVIEW_MAX_EVENT)> g_previewEvents;
68     std::bitset<static_cast<unsigned int>(CAM_VIDEO_EVENTS::CAM_VIDEO_MAX_EVENT)> g_videoEvents;
69     std::unordered_map<std::string, int> g_camStatusMap;
70     std::unordered_map<std::string, bool> g_camFlashMap;
71 
72     class AppCallback : public CameraManagerCallback, public ErrorCallback, public PhotoStateCallback,
73                         public PreviewStateCallback {
74     public:
OnCameraStatusChanged(const CameraStatusInfo & cameraDeviceInfo) const75         void OnCameraStatusChanged(const CameraStatusInfo &cameraDeviceInfo) const override
76         {
77             const std::string cameraID = cameraDeviceInfo.cameraDevice->GetID();
78             const CameraStatus cameraStatus = cameraDeviceInfo.cameraStatus;
79 
80             switch (cameraStatus) {
81                 case CAMERA_STATUS_UNAVAILABLE: {
82                     MEDIA_DEBUG_LOG("AppCallback::OnCameraStatusChanged %{public}s: CAMERA_STATUS_UNAVAILABLE",
83                                     cameraID.c_str());
84                     g_camStatusMap[cameraID] = CAMERA_STATUS_UNAVAILABLE;
85                     break;
86                 }
87                 case CAMERA_STATUS_AVAILABLE: {
88                     MEDIA_DEBUG_LOG("AppCallback::OnCameraStatusChanged %{public}s: CAMERA_STATUS_AVAILABLE",
89                                     cameraID.c_str());
90                     g_camStatusMap[cameraID] = CAMERA_STATUS_AVAILABLE;
91                     break;
92                 }
93                 default: {
94                     MEDIA_DEBUG_LOG("AppCallback::OnCameraStatusChanged %{public}s: unknown", cameraID.c_str());
95                     EXPECT_TRUE(false);
96                 }
97             }
98             return;
99         }
100 
OnFlashlightStatusChanged(const std::string & cameraID,const FlashStatus flashStatus) const101         void OnFlashlightStatusChanged(const std::string &cameraID, const FlashStatus flashStatus) const override
102         {
103             switch (flashStatus) {
104                 case FLASH_STATUS_OFF: {
105                     MEDIA_DEBUG_LOG("AppCallback::OnFlashlightStatusChanged %{public}s: FLASH_STATUS_OFF",
106                                     cameraID.c_str());
107                     g_camFlashMap[cameraID] = false;
108                     break;
109                 }
110                 case FLASH_STATUS_ON: {
111                     MEDIA_DEBUG_LOG("AppCallback::OnFlashlightStatusChanged %{public}s: FLASH_STATUS_ON",
112                                     cameraID.c_str());
113                     g_camFlashMap[cameraID] = true;
114                     break;
115                 }
116                 case FLASH_STATUS_UNAVAILABLE: {
117                     MEDIA_DEBUG_LOG("AppCallback::OnFlashlightStatusChanged %{public}s: FLASH_STATUS_UNAVAILABLE",
118                                     cameraID.c_str());
119                     g_camFlashMap.erase(cameraID);
120                     break;
121                 }
122                 default: {
123                     MEDIA_DEBUG_LOG("AppCallback::OnFlashlightStatusChanged %{public}s: unknown", cameraID.c_str());
124                     EXPECT_TRUE(false);
125                 }
126             }
127             return;
128         }
129 
OnError(const int32_t errorType,const int32_t errorMsg) const130         void OnError(const int32_t errorType, const int32_t errorMsg) const override
131         {
132             MEDIA_DEBUG_LOG("AppCallback::OnError errorType: %{public}d, errorMsg: %{public}d", errorType, errorMsg);
133             g_camInputOnError = true;
134             if (errorType == CAMERA_DEVICE_PREEMPTED) {
135                 g_sessionclosed = true;
136             }
137             return;
138         }
139 
OnCaptureStarted(const int32_t captureId) const140         void OnCaptureStarted(const int32_t captureId) const override
141         {
142             MEDIA_DEBUG_LOG("AppCallback::OnCaptureStarted captureId: %{public}d", captureId);
143             g_photoEvents[static_cast<int>(CAM_PHOTO_EVENTS::CAM_PHOTO_CAPTURE_START)] = 1;
144             return;
145         }
146 
OnCaptureEnded(const int32_t captureId,const int32_t frameCount) const147         void OnCaptureEnded(const int32_t captureId, const int32_t frameCount) const override
148         {
149             MEDIA_DEBUG_LOG("AppCallback::OnCaptureEnded captureId: %{public}d, frameCount: %{public}d",
150                             captureId, frameCount);
151             g_photoEvents[static_cast<int>(CAM_PHOTO_EVENTS::CAM_PHOTO_CAPTURE_END)] = 1;
152             return;
153         }
154 
OnFrameShutter(const int32_t captureId,const uint64_t timestamp) const155         void OnFrameShutter(const int32_t captureId, const uint64_t timestamp) const override
156         {
157             MEDIA_DEBUG_LOG("AppCallback::OnFrameShutter captureId: %{public}d, timestamp: %{public}"
158                             PRIu64, captureId, timestamp);
159             g_photoEvents[static_cast<int>(CAM_PHOTO_EVENTS::CAM_PHOTO_FRAME_SHUTTER)] = 1;
160             return;
161         }
162 
OnCaptureError(const int32_t captureId,const int32_t errorCode) const163         void OnCaptureError(const int32_t captureId, const int32_t errorCode) const override
164         {
165             MEDIA_DEBUG_LOG("AppCallback::OnCaptureError captureId: %{public}d, errorCode: %{public}d",
166                             captureId, errorCode);
167             g_photoEvents[static_cast<int>(CAM_PHOTO_EVENTS::CAM_PHOTO_CAPTURE_ERR)] = 1;
168             return;
169         }
170 
OnFrameStarted() const171         void OnFrameStarted() const override
172         {
173             MEDIA_DEBUG_LOG("AppCallback::OnFrameStarted");
174             g_previewEvents[static_cast<int>(CAM_PREVIEW_EVENTS::CAM_PREVIEW_FRAME_START)] = 1;
175             return;
176         }
OnFrameEnded(const int32_t frameCount) const177         void OnFrameEnded(const int32_t frameCount) const override
178         {
179             MEDIA_DEBUG_LOG("AppCallback::OnFrameEnded frameCount: %{public}d", frameCount);
180             g_previewEvents[static_cast<int>(CAM_PREVIEW_EVENTS::CAM_PREVIEW_FRAME_END)] = 1;
181             return;
182         }
OnError(const int32_t errorCode) const183         void OnError(const int32_t errorCode) const override
184         {
185             MEDIA_DEBUG_LOG("AppCallback::OnError errorCode: %{public}d", errorCode);
186             g_previewEvents[static_cast<int>(CAM_PREVIEW_EVENTS::CAM_PREVIEW_FRAME_ERR)] = 1;
187             return;
188         }
189     };
190 
191     class AppVideoCallback : public VideoStateCallback {
OnFrameStarted() const192         void OnFrameStarted() const override
193         {
194             MEDIA_DEBUG_LOG("AppVideoCallback::OnFrameStarted");
195             g_videoEvents[static_cast<int>(CAM_VIDEO_EVENTS::CAM_VIDEO_FRAME_START)] = 1;
196             return;
197         }
OnFrameEnded(const int32_t frameCount) const198         void OnFrameEnded(const int32_t frameCount) const override
199         {
200             MEDIA_DEBUG_LOG("AppVideoCallback::OnFrameEnded frameCount: %{public}d", frameCount);
201             g_videoEvents[static_cast<int>(CAM_VIDEO_EVENTS::CAM_VIDEO_FRAME_END)] = 1;
202             return;
203         }
OnError(const int32_t errorCode) const204         void OnError(const int32_t errorCode) const override
205         {
206             MEDIA_DEBUG_LOG("AppVideoCallback::OnError errorCode: %{public}d", errorCode);
207             g_videoEvents[static_cast<int>(CAM_VIDEO_EVENTS::CAM_VIDEO_FRAME_ERR)] = 1;
208             return;
209         }
210     };
211 
212     class AppMetadataCallback : public MetadataObjectCallback, public MetadataStateCallback {
213     public:
OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const214         void OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const
215         {
216             MEDIA_DEBUG_LOG("AppMetadataCallback::OnMetadataObjectsAvailable received");
217         }
OnError(int32_t errorCode) const218         void OnError(int32_t errorCode) const
219         {
220             MEDIA_DEBUG_LOG("AppMetadataCallback::OnError %{public}d", errorCode);
221         }
222     };
223 } // namespace
224 
CreatePhotoOutput(int32_t width,int32_t height)225 sptr<CaptureOutput> CameraFrameworkModuleTest::CreatePhotoOutput(int32_t width, int32_t height)
226 {
227     sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
228     CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
229     Size photoSize;
230     photoSize.width = width;
231     photoSize.height = height;
232     Profile photoProfile = Profile(photoFormat, photoSize);
233     sptr<CaptureOutput> photoOutput = nullptr;
234     photoOutput = manager_->CreatePhotoOutput(photoProfile, surface);
235     return photoOutput;
236 }
237 
CreatePhotoOutput()238 sptr<CaptureOutput> CameraFrameworkModuleTest::CreatePhotoOutput()
239 {
240     sptr<CaptureOutput> photoOutput = CreatePhotoOutput(photoWidth_, photoHeight_);
241     return photoOutput;
242 }
243 
CreatePreviewOutput(int32_t width,int32_t height)244 sptr<CaptureOutput> CameraFrameworkModuleTest::CreatePreviewOutput(int32_t width, int32_t height)
245 {
246     sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
247     CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
248     Size previewSize;
249     previewSize.width = width;
250     previewSize.height = height;
251     Profile previewProfile = Profile(previewFormat, previewSize);
252     sptr<CaptureOutput> previewOutput = nullptr;
253     previewOutput = manager_->CreatePreviewOutput(previewProfile, surface);
254     return previewOutput;
255 }
256 
CreatePreviewOutput()257 sptr<CaptureOutput> CameraFrameworkModuleTest::CreatePreviewOutput()
258 {
259     sptr<CaptureOutput> previewOutput = CreatePreviewOutput(previewWidth_, previewHeight_);
260     return previewOutput;
261 }
262 
CreateVideoOutput(int32_t width,int32_t height)263 sptr<CaptureOutput> CameraFrameworkModuleTest::CreateVideoOutput(int32_t width, int32_t height)
264 {
265     sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
266     CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
267     Size videoSize;
268     videoSize.width = width;
269     videoSize.height = height;
270     std::vector<int32_t> frameRate = {30, 30};
271     VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, frameRate);
272     sptr<CaptureOutput> videoOutput = nullptr;
273     videoOutput = manager_->CreateVideoOutput(videoProfile, surface);
274     return videoOutput;
275 }
276 
CreateVideoOutput()277 sptr<CaptureOutput> CameraFrameworkModuleTest::CreateVideoOutput()
278 {
279     sptr<CaptureOutput> videoOutput = CreateVideoOutput(videoWidth_, videoHeight_);
280     return videoOutput;
281 }
282 
SetCameraParameters(sptr<CaptureSession> & session,bool video)283 void CameraFrameworkModuleTest::SetCameraParameters(sptr<CaptureSession> &session, bool video)
284 {
285     session->LockForControl();
286 
287     std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
288     if (!zoomRatioRange.empty()) {
289         session->SetZoomRatio(zoomRatioRange[0]);
290     }
291 
292     // GetExposureBiasRange
293     std::vector<int32_t> exposureBiasRange = session->GetExposureBiasRange();
294     if (!exposureBiasRange.empty()) {
295         session->SetExposureBias(exposureBiasRange[0]);
296     }
297 
298     // Get/Set Exposurepoint
299     Point exposurePoint = {1, 2};
300     session->SetMeteringPoint(exposurePoint);
301 
302     // GetFocalLength
303     float focalLength = session->GetFocalLength();
304     ASSERT_NE(focalLength, 0);
305 
306     // Get/Set focuspoint
307     Point focusPoint = {1, 2};
308     session->SetFocusPoint(focusPoint);
309 
310     FlashMode flash = FLASH_MODE_OPEN;
311     if (video) {
312         flash = FLASH_MODE_ALWAYS_OPEN;
313     }
314     session->SetFlashMode(flash);
315 
316     FocusMode focus = FOCUS_MODE_AUTO;
317     session->SetFocusMode(focus);
318 
319     ExposureMode exposure = EXPOSURE_MODE_AUTO;
320     session->SetExposureMode(exposure);
321 
322     session->UnlockForControl();
323 
324     Point exposurePointGet = session->GetMeteringPoint();
325     EXPECT_EQ(exposurePointGet.x, exposurePoint.x);
326     EXPECT_EQ(exposurePointGet.y, exposurePoint.y);
327 
328     Point focusPointGet = session->GetFocusPoint();
329     EXPECT_EQ(focusPointGet.x, focusPoint.x);
330     EXPECT_EQ(focusPointGet.y, focusPoint.y);
331 
332     if (!zoomRatioRange.empty()) {
333         EXPECT_EQ(session->GetZoomRatio(), zoomRatioRange[0]);
334     }
335 
336     // exposureBiasRange
337     if (!exposureBiasRange.empty()) {
338         EXPECT_EQ(session->GetExposureValue(), exposureBiasRange[0]);
339     }
340 
341     EXPECT_EQ(session->GetFlashMode(), flash);
342     EXPECT_EQ(session->GetFocusMode(), focus);
343     EXPECT_EQ(session->GetExposureMode(), exposure);
344 }
345 
TestCallbacksSession(sptr<CaptureOutput> photoOutput,sptr<CaptureOutput> videoOutput)346 void CameraFrameworkModuleTest::TestCallbacksSession(sptr<CaptureOutput> photoOutput,
347     sptr<CaptureOutput> videoOutput)
348 {
349     int32_t intResult;
350 
351     if (videoOutput != nullptr) {
352         intResult = session_->Start();
353         EXPECT_EQ(intResult, 0);
354 
355         intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
356         EXPECT_EQ(intResult, 0);
357         sleep(WAIT_TIME_AFTER_START);
358     }
359 
360     if (photoOutput != nullptr) {
361         intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture();
362         EXPECT_EQ(intResult, 0);
363     }
364 
365     if (videoOutput != nullptr) {
366         intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
367         EXPECT_EQ(intResult, 0);
368     }
369 
370     sleep(WAIT_TIME_BEFORE_STOP);
371     session_->Stop();
372 }
373 
TestCallbacks(sptr<CameraDevice> & cameraInfo,bool video)374 void CameraFrameworkModuleTest::TestCallbacks(sptr<CameraDevice> &cameraInfo, bool video)
375 {
376     int32_t intResult = session_->BeginConfig();
377     EXPECT_EQ(intResult, 0);
378 
379     // Register error callback
380     std::shared_ptr<AppCallback> callback = std::make_shared<AppCallback>();
381     sptr<CameraInput> camInput = (sptr<CameraInput> &)input_;
382     camInput->SetErrorCallback(callback);
383 
384     EXPECT_EQ(g_camInputOnError, false);
385 
386     intResult = session_->AddInput(input_);
387     EXPECT_EQ(intResult, 0);
388 
389     SetCameraParameters(session_, video);
390 
391     sptr<CaptureOutput> photoOutput = nullptr;
392     sptr<CaptureOutput> videoOutput = nullptr;
393     if (!video) {
394         photoOutput = CreatePhotoOutput();
395         ASSERT_NE(photoOutput, nullptr);
396 
397         // Register photo callback
398         ((sptr<PhotoOutput> &)photoOutput)->SetCallback(std::make_shared<AppCallback>());
399         intResult = session_->AddOutput(photoOutput);
400     } else {
401         videoOutput = CreateVideoOutput();
402         ASSERT_NE(videoOutput, nullptr);
403 
404         // Register video callback
405         ((sptr<VideoOutput> &)videoOutput)->SetCallback(std::make_shared<AppVideoCallback>());
406         intResult = session_->AddOutput(videoOutput);
407     }
408 
409     EXPECT_EQ(intResult, 0);
410 
411     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
412     ASSERT_NE(previewOutput, nullptr);
413 
414     // Register preview callback
415     ((sptr<PreviewOutput> &)previewOutput)->SetCallback(std::make_shared<AppCallback>());
416     intResult = session_->AddOutput(previewOutput);
417     EXPECT_EQ(intResult, 0);
418 
419     intResult = session_->CommitConfig();
420     EXPECT_EQ(intResult, 0);
421 
422     /* In case of wagner device, once commit config is done with flash on
423     it is not giving the flash status callback, removing it */
424     EXPECT_TRUE(g_photoEvents.none());
425     EXPECT_TRUE(g_previewEvents.none());
426     EXPECT_TRUE(g_videoEvents.none());
427 
428     TestCallbacksSession(photoOutput, videoOutput);
429 
430     if (photoOutput != nullptr) {
431         EXPECT_TRUE(g_photoEvents[static_cast<int>(CAM_PHOTO_EVENTS::CAM_PHOTO_CAPTURE_START)] == 1);
432         /* In case of wagner device, frame shutter callback not working,
433         hence removed. Once supported by hdi, the same needs to be
434         enabled */
435         ((sptr<PhotoOutput> &)photoOutput)->Release();
436     }
437 
438     if (videoOutput != nullptr) {
439         EXPECT_EQ(g_previewEvents[static_cast<int>(CAM_PREVIEW_EVENTS::CAM_PREVIEW_FRAME_START)], 1);
440 
441         TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
442 
443         EXPECT_EQ(g_videoEvents[static_cast<int>(CAM_VIDEO_EVENTS::CAM_VIDEO_FRAME_START)], 1);
444         EXPECT_EQ(g_videoEvents[static_cast<int>(CAM_VIDEO_EVENTS::CAM_VIDEO_FRAME_END)], 1);
445 
446         ((sptr<VideoOutput> &)videoOutput)->Release();
447     }
448 
449     ((sptr<PreviewOutput> &)previewOutput)->Release();
450 }
451 
SetUpTestCase(void)452 void CameraFrameworkModuleTest::SetUpTestCase(void) {}
TearDownTestCase(void)453 void CameraFrameworkModuleTest::TearDownTestCase(void) {}
454 
SetUpInit()455 void CameraFrameworkModuleTest::SetUpInit()
456 {
457     MEDIA_DEBUG_LOG("Beginning of camera test case!");
458     g_photoEvents.reset();
459     g_previewEvents.reset();
460     g_videoEvents.reset();
461     g_camStatusMap.clear();
462     g_camFlashMap.clear();
463     g_camInputOnError = false;
464     g_videoFd = -1;
465 
466     previewFormat_ = CAMERA_FORMAT_YUV_420_SP;
467     videoFormat_ = CAMERA_FORMAT_YUV_420_SP;
468     photoFormat_ = CAMERA_FORMAT_JPEG;
469     previewWidth_ = PREVIEW_DEFAULT_WIDTH;
470     previewHeight_ = PREVIEW_DEFAULT_HEIGHT;
471     photoWidth_ = PHOTO_DEFAULT_WIDTH;
472     photoHeight_ = PHOTO_DEFAULT_HEIGHT;
473     videoWidth_ = VIDEO_DEFAULT_WIDTH;
474     videoHeight_ = VIDEO_DEFAULT_HEIGHT;
475 }
476 
SetUp()477 void CameraFrameworkModuleTest::SetUp()
478 {
479     SetUpInit();
480     // set native token
481     uint64_t tokenId;
482     const char *perms[2];
483     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
484     perms[1] = "ohos.permission.CAMERA";
485     NativeTokenInfoParams infoInstance = {
486         .dcapsNum = 0,
487         .permsNum = 2,
488         .aclsNum = 0,
489         .dcaps = NULL,
490         .perms = perms,
491         .acls = NULL,
492         .processName = "native_camera_tdd",
493         .aplStr = "system_basic",
494     };
495     tokenId = GetAccessTokenId(&infoInstance);
496     SetSelfTokenID(tokenId);
497     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
498 
499     manager_ = CameraManager::GetInstance();
500     ASSERT_NE(manager_, nullptr);
501     manager_->SetCallback(std::make_shared<AppCallback>());
502 
503     cameras_ = manager_->GetSupportedCameras();
504     ASSERT_TRUE(cameras_.size() != 0);
505 
506     input_ = manager_->CreateCameraInput(cameras_[0]);
507     ASSERT_NE(input_, nullptr);
508 
509     sptr<CameraManager> camManagerObj = CameraManager::GetInstance();
510     std::vector<sptr<CameraDevice>> cameraObjList = camManagerObj->GetSupportedCameras();
511     sptr<CameraOutputCapability> outputcapability =  camManagerObj->GetSupportedOutputCapability(cameraObjList[0]);
512     std::vector<Profile> previewProfiles = outputcapability->GetPreviewProfiles();
513     for (auto i : previewProfiles) {
514         previewFormats_.push_back(i.GetCameraFormat());
515         previewSizes_.push_back(i.GetSize());
516     }
517     ASSERT_TRUE(!previewFormats_.empty());
518     ASSERT_TRUE(!previewSizes_.empty());
519     if (std::find(previewFormats_.begin(), previewFormats_.end(), CAMERA_FORMAT_YUV_420_SP)
520         != previewFormats_.end()) {
521         previewFormat_ = CAMERA_FORMAT_YUV_420_SP;
522     } else {
523         previewFormat_ = previewFormats_[0];
524     }
525     std::vector<Profile> photoProfiles =  outputcapability->GetPhotoProfiles();
526         for (auto i : photoProfiles) {
527             photoFormats_.push_back(i.GetCameraFormat());
528             photoSizes_.push_back(i.GetSize());
529         }
530     ASSERT_TRUE(!photoFormats_.empty());
531     ASSERT_TRUE(!photoSizes_.empty());
532     photoFormat_ = photoFormats_[0];
533     std::vector<VideoProfile> videoProfiles = outputcapability->GetVideoProfiles();
534     for (auto i : videoProfiles) {
535         videoFormats_.push_back(i.GetCameraFormat());
536         videoSizes_.push_back(i.GetSize());
537         videoFrameRates_ = i.GetFrameRates();
538     }
539     ASSERT_TRUE(!videoFormats_.empty());
540     ASSERT_TRUE(!videoSizes_.empty());
541     ASSERT_TRUE(!videoFrameRates_.empty());
542     if (std::find(videoFormats_.begin(), videoFormats_.end(), CAMERA_FORMAT_YUV_420_SP)
543         != videoFormats_.end()) {
544         videoFormat_ = CAMERA_FORMAT_YUV_420_SP;
545     } else {
546         videoFormat_ = videoFormats_[0];
547     }
548     Size size = previewSizes_.back();
549     previewWidth_ = size.width;
550     previewHeight_ = size.height;
551     size = photoSizes_.back();
552     photoWidth_ = size.width;
553     photoHeight_ = size.height;
554     size = videoSizes_.back();
555     videoWidth_ = size.width;
556     videoHeight_ = size.height;
557 
558     sptr<CameraInput> camInput = (sptr<CameraInput> &)input_;
559     camInput->Open();
560 
561     session_ = manager_->CreateCaptureSession();
562     ASSERT_NE(session_, nullptr);
563 }
564 
TearDown()565 void CameraFrameworkModuleTest::TearDown()
566 {
567     if (session_) {
568         session_->Release();
569     }
570     if (input_) {
571         sptr<CameraInput> camInput = (sptr<CameraInput> &)input_;
572         camInput->Close();
573         input_->Release();
574     }
575     MEDIA_DEBUG_LOG("End of camera test case");
576 }
577 
578 /*
579  * Feature: Framework
580  * Function: Test Capture
581  * SubFunction: NA
582  * FunctionPoints: NA
583  * EnvConditions: NA
584  * CaseDescription: Test Capture
585  */
586 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_001, TestSize.Level0)
587 {
588     int32_t intResult = session_->BeginConfig();
589     EXPECT_EQ(intResult, 0);
590 
591     intResult = session_->AddInput(input_);
592     EXPECT_EQ(intResult, 0);
593 
594     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
595     ASSERT_NE(photoOutput, nullptr);
596 
597     intResult = session_->AddOutput(photoOutput);
598     EXPECT_EQ(intResult, 0);
599 
600     intResult = session_->CommitConfig();
601     EXPECT_EQ(intResult, 0);
602 
603     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture();
604     EXPECT_EQ(intResult, 0);
605     sleep(WAIT_TIME_AFTER_CAPTURE);
606 
607     ((sptr<PhotoOutput> &)photoOutput)->Release();
608 }
609 /*
610  * Feature: Framework
611  * Function: Test Capture + Preview
612  * SubFunction: NA
613  * FunctionPoints: NA
614  * EnvConditions: NA
615  * CaseDescription: Test Capture + Preview
616  */
617 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_002, TestSize.Level0)
618 {
619     int32_t intResult = session_->BeginConfig();
620     EXPECT_EQ(intResult, 0);
621 
622     intResult = session_->AddInput(input_);
623     EXPECT_EQ(intResult, 0);
624 
625     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
626     ASSERT_NE(photoOutput, nullptr);
627 
628     intResult = session_->AddOutput(photoOutput);
629     EXPECT_EQ(intResult, 0);
630 
631     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
632     ASSERT_NE(previewOutput, nullptr);
633 
634     intResult = session_->AddOutput(previewOutput);
635     EXPECT_EQ(intResult, 0);
636 
637     intResult = session_->CommitConfig();
638     EXPECT_EQ(intResult, 0);
639 
640     sleep(WAIT_TIME_AFTER_START);
641     intResult = ((sptr<PreviewOutput> &)previewOutput)->Start();
642     EXPECT_EQ(intResult, 0);
643 
644     sleep(WAIT_TIME_AFTER_START);
645     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture();
646     EXPECT_EQ(intResult, 0);
647     sleep(WAIT_TIME_AFTER_CAPTURE);
648 
649     ((sptr<PreviewOutput> &)previewOutput)->Stop();
650     session_->Stop();
651 }
652 
653 /*
654  * Feature: Framework
655  * Function: Test Preview + Video
656  * SubFunction: NA
657  * FunctionPoints: NA
658  * EnvConditions: NA
659  * CaseDescription: Test Preview + Video
660  */
661 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_003, TestSize.Level0)
662 {
663     int32_t intResult = session_->BeginConfig();
664     EXPECT_EQ(intResult, 0);
665 
666     intResult = session_->AddInput(input_);
667     EXPECT_EQ(intResult, 0);
668 
669     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
670     ASSERT_NE(previewOutput, nullptr);
671 
672     intResult = session_->AddOutput(previewOutput);
673     EXPECT_EQ(intResult, 0);
674 
675     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
676     ASSERT_NE(videoOutput, nullptr);
677 
678     intResult = session_->AddOutput(videoOutput);
679     EXPECT_EQ(intResult, 0);
680 
681     intResult = session_->CommitConfig();
682     EXPECT_EQ(intResult, 0);
683 
684     sleep(WAIT_TIME_AFTER_START);
685     intResult = ((sptr<PreviewOutput> &)previewOutput)->Start();
686     EXPECT_EQ(intResult, 0);
687 
688     sleep(WAIT_TIME_AFTER_START);
689 
690     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
691     EXPECT_EQ(intResult, 0);
692 
693     sleep(WAIT_TIME_AFTER_START);
694 
695     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
696     EXPECT_EQ(intResult, 0);
697 
698     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
699 
700     sleep(WAIT_TIME_BEFORE_STOP);
701     ((sptr<PreviewOutput> &)previewOutput)->Stop();
702     session_->Stop();
703 }
704 
705 /*
706  * Feature: Framework
707  * Function: Test camera status, flash, camera input, photo output and preview output callbacks
708  * SubFunction: NA
709  * FunctionPoints: NA
710  * EnvConditions: NA
711  * CaseDescription: Test callbacks
712  */
713 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_004, TestSize.Level0)
714 {
715     TestCallbacks(cameras_[0], false);
716 }
717 
718 /*
719  * Feature: Framework
720  * Function: Test camera status, flash, camera input, preview output and video output callbacks
721  * SubFunction: NA
722  * FunctionPoints: NA
723  * EnvConditions: NA
724  * CaseDescription: Test callbacks
725  */
726 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_005, TestSize.Level0)
727 {
728     TestCallbacks(cameras_[0], true);
729 }
730 
731 /*
732  * Feature: Framework
733  * Function: Test Preview
734  * SubFunction: NA
735  * FunctionPoints: NA
736  * EnvConditions: NA
737  * CaseDescription: Test Preview
738  */
739 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_006, TestSize.Level0)
740 {
741     int32_t intResult = session_->BeginConfig();
742     EXPECT_EQ(intResult, 0);
743 
744     intResult = session_->AddInput(input_);
745     EXPECT_EQ(intResult, 0);
746 
747     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
748     ASSERT_NE(previewOutput, nullptr);
749 
750     intResult = session_->AddOutput(previewOutput);
751     EXPECT_EQ(intResult, 0);
752 
753     intResult = session_->CommitConfig();
754     EXPECT_EQ(intResult, 0);
755 
756     sleep(WAIT_TIME_AFTER_START);
757     intResult = ((sptr<PreviewOutput> &)previewOutput)->Start();
758     EXPECT_EQ(intResult, 0);
759 
760     sleep(WAIT_TIME_AFTER_START);
761 
762     ((sptr<PreviewOutput> &)previewOutput)->Stop();
763     session_->Stop();
764 }
765 
766 /*
767  * Feature: Framework
768  * Function: Test Video
769  * SubFunction: NA
770  * FunctionPoints: NA
771  * EnvConditions: NA
772  * CaseDescription: Test Video
773  */
774 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_007, TestSize.Level0)
775 {
776     int32_t intResult = session_->BeginConfig();
777     EXPECT_EQ(intResult, 0);
778 
779     intResult = session_->AddInput(input_);
780     EXPECT_EQ(intResult, 0);
781 
782     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
783     ASSERT_NE(videoOutput, nullptr);
784 
785     intResult = session_->AddOutput(videoOutput);
786     EXPECT_EQ(intResult, 0);
787 
788     intResult = session_->CommitConfig();
789     EXPECT_EQ(intResult, 0);
790     // Video mode without preview is not supported
791 }
792 
793 /*
794  * Feature: Framework
795  * Function: Test Custom Preview with invalid resolutions
796  * SubFunction: NA
797  * FunctionPoints: NA
798  * EnvConditions: NA
799  * CaseDescription: Test Custom Preview with invalid resolution(0 * 0)
800  */
801 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_011, TestSize.Level0)
802 {
803     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
804     ASSERT_NE(previewOutput, nullptr);
805 }
806 
807 /*
808  * Feature: Framework
809  * Function: Test capture session with commit config multiple times
810  * SubFunction: NA
811  * FunctionPoints: NA
812  * EnvConditions: NA
813  * CaseDescription: Test capture session with commit config multiple times
814  */
815 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_017, TestSize.Level0)
816 {
817     int32_t intResult = session_->BeginConfig();
818     EXPECT_EQ(intResult, 0);
819 
820     intResult = session_->AddInput(input_);
821     EXPECT_EQ(intResult, 0);
822 
823     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
824     ASSERT_NE(previewOutput, nullptr);
825 
826     intResult = session_->AddOutput(previewOutput);
827     EXPECT_EQ(intResult, 0);
828 
829     intResult = session_->CommitConfig();
830     EXPECT_EQ(intResult, 0);
831 
832     sleep(WAIT_TIME_AFTER_START);
833 
834     intResult = session_->CommitConfig();
835     EXPECT_NE(intResult, 0);
836 }
837 
838 /*
839  * Feature: Framework
840  * Function: Test capture session add input with invalid value
841  * SubFunction: NA
842  * FunctionPoints: NA
843  * EnvConditions: NA
844  * CaseDescription: Test capture session add input with invalid value
845  */
846 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_018, TestSize.Level0)
847 {
848     int32_t intResult = session_->BeginConfig();
849     EXPECT_EQ(intResult, 0);
850 
851     sptr<CaptureInput> input1 = nullptr;
852     intResult = session_->AddInput(input1);
853     EXPECT_NE(intResult, 0);
854 
855     session_->Stop();
856 }
857 
858 /*
859  * Feature: Framework
860  * Function: Test capture session add output with invalid value
861  * SubFunction: NA
862  * FunctionPoints: NA
863  * EnvConditions: NA
864  * CaseDescription: Test capture session add output with invalid value
865  */
866 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_019, TestSize.Level0)
867 {
868     int32_t intResult = session_->BeginConfig();
869     EXPECT_EQ(intResult, 0);
870 
871     sptr<CaptureOutput> previewOutput = nullptr;
872     intResult = session_->AddOutput(previewOutput);
873     EXPECT_NE(intResult, 0);
874 
875     session_->Stop();
876 }
877 
878 /*
879  * Feature: Framework
880  * Function: Test capture session commit config without adding input
881  * SubFunction: NA
882  * FunctionPoints: NA
883  * EnvConditions: NA
884  * CaseDescription: Test capture session commit config without adding input
885  */
886 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_020, TestSize.Level0)
887 {
888     int32_t intResult = session_->BeginConfig();
889     EXPECT_EQ(intResult, 0);
890 
891     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
892     ASSERT_NE(previewOutput, nullptr);
893 
894     intResult = session_->AddOutput(previewOutput);
895     EXPECT_EQ(intResult, 0);
896 
897     intResult = session_->CommitConfig();
898     EXPECT_NE(intResult, 0);
899 
900     session_->Stop();
901 }
902 
903 /*
904  * Feature: Framework
905  * Function: Test capture session commit config without adding output
906  * SubFunction: NA
907  * FunctionPoints: NA
908  * EnvConditions: NA
909  * CaseDescription: Test capture session commit config without adding output
910  */
911 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_021, TestSize.Level0)
912 {
913     int32_t intResult = session_->BeginConfig();
914     EXPECT_EQ(intResult, 0);
915 
916     intResult = session_->AddInput(input_);
917     EXPECT_EQ(intResult, 0);
918 
919     intResult = session_->CommitConfig();
920     EXPECT_NE(intResult, 0);
921 
922     session_->Stop();
923 }
924 
925 /*
926  * Feature: Framework
927  * Function: Test capture session start and stop without adding preview output
928  * SubFunction: NA
929  * FunctionPoints: NA
930  * EnvConditions: NA
931  * CaseDescription: Test capture session start and stop without adding preview output
932  */
933 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_022, TestSize.Level0)
934 {
935     int32_t intResult = session_->BeginConfig();
936     EXPECT_EQ(intResult, 0);
937 
938     intResult = session_->AddInput(input_);
939     EXPECT_EQ(intResult, 0);
940 
941     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
942     ASSERT_NE(photoOutput, nullptr);
943 
944     intResult = session_->AddOutput(photoOutput);
945     EXPECT_EQ(intResult, 0);
946 
947     intResult = session_->CommitConfig();
948     EXPECT_EQ(intResult, 0);
949 
950     intResult = session_->Start();
951     EXPECT_EQ(intResult, 0);
952 
953     intResult = session_->Stop();
954     EXPECT_EQ(intResult, 0);
955 }
956 
957 /*
958  * Feature: Framework
959  * Function: Test capture session without begin config
960  * SubFunction: NA
961  * FunctionPoints: NA
962  * EnvConditions: NA
963  * CaseDescription: Test capture session without begin config
964  */
965 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_023, TestSize.Level0)
966 {
967     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
968     ASSERT_NE(photoOutput, nullptr);
969 
970     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
971     ASSERT_NE(previewOutput, nullptr);
972 
973     int32_t intResult = session_->AddInput(input_);
974     EXPECT_NE(intResult, 0);
975 
976     intResult = session_->AddOutput(photoOutput);
977     EXPECT_NE(intResult, 0);
978 
979     intResult = session_->AddOutput(previewOutput);
980     EXPECT_NE(intResult, 0);
981 
982     intResult = session_->CommitConfig();
983     EXPECT_NE(intResult, 0);
984 
985     intResult = session_->Start();
986     EXPECT_NE(intResult, 0);
987 
988     sleep(WAIT_TIME_AFTER_START);
989     intResult = ((sptr<PreviewOutput> &)previewOutput)->Start();
990     EXPECT_NE(intResult, 0);
991 
992     sleep(WAIT_TIME_AFTER_START);
993     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture();
994     EXPECT_NE(intResult, 0);
995     sleep(WAIT_TIME_AFTER_CAPTURE);
996 
997     ((sptr<PreviewOutput> &)previewOutput)->Stop();
998     session_->Stop();
999 }
1000 
1001 /*
1002  * Feature: Framework
1003  * Function: Test capture session with multiple photo outputs
1004  * SubFunction: NA
1005  * FunctionPoints: NA
1006  * EnvConditions: NA
1007  * CaseDescription: Test capture session with multiple photo outputs
1008  */
1009 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_024, TestSize.Level0)
1010 {
1011     int32_t intResult = session_->BeginConfig();
1012     EXPECT_EQ(intResult, 0);
1013 
1014     intResult = session_->AddInput(input_);
1015     EXPECT_EQ(intResult, 0);
1016 
1017     sptr<CaptureOutput> photoOutput1 = CreatePhotoOutput();
1018     ASSERT_NE(photoOutput1, nullptr);
1019 
1020     intResult = session_->AddOutput(photoOutput1);
1021     EXPECT_EQ(intResult, 0);
1022 
1023     sptr<CaptureOutput> photoOutput2 = CreatePhotoOutput();
1024     ASSERT_NE(photoOutput2, nullptr);
1025 
1026     intResult = session_->AddOutput(photoOutput2);
1027     EXPECT_EQ(intResult, 0);
1028 
1029     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1030     ASSERT_NE(previewOutput, nullptr);
1031 
1032     intResult = session_->AddOutput(previewOutput);
1033     EXPECT_EQ(intResult, 0);
1034 
1035     intResult = session_->CommitConfig();
1036     EXPECT_EQ(intResult, 0);
1037 
1038     intResult = session_->Start();
1039     EXPECT_EQ(intResult, 0);
1040 
1041     sleep(WAIT_TIME_AFTER_START);
1042     intResult = ((sptr<PhotoOutput> &)photoOutput1)->Capture();
1043     EXPECT_EQ(intResult, 0);
1044     sleep(WAIT_TIME_AFTER_CAPTURE);
1045 
1046     intResult = ((sptr<PhotoOutput> &)photoOutput2)->Capture();
1047     EXPECT_EQ(intResult, 0);
1048     sleep(WAIT_TIME_AFTER_CAPTURE);
1049 
1050     ((sptr<PreviewOutput> &)previewOutput)->Stop();
1051     session_->Stop();
1052 
1053     ((sptr<PhotoOutput> &)photoOutput1)->Release();
1054     ((sptr<PhotoOutput> &)photoOutput2)->Release();
1055 }
1056 
1057 /*
1058  * Feature: Framework
1059  * Function: Test capture session with multiple preview outputs
1060  * SubFunction: NA
1061  * FunctionPoints: NA
1062  * EnvConditions: NA
1063  * CaseDescription: Test capture session with multiple preview ouputs
1064  */
1065 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_025, TestSize.Level0)
1066 {
1067     int32_t intResult = session_->BeginConfig();
1068     EXPECT_EQ(intResult, 0);
1069 
1070     intResult = session_->AddInput(input_);
1071     EXPECT_EQ(intResult, 0);
1072 
1073     sptr<CaptureOutput> previewOutput1 = CreatePreviewOutput();
1074     ASSERT_NE(previewOutput1, nullptr);
1075 
1076     intResult = session_->AddOutput(previewOutput1);
1077     EXPECT_EQ(intResult, 0);
1078 
1079     sptr<CaptureOutput> previewOutput2 = CreatePreviewOutput();
1080     ASSERT_NE(previewOutput2, nullptr);
1081 
1082     intResult = session_->AddOutput(previewOutput2);
1083     EXPECT_EQ(intResult, 0);
1084 
1085     intResult = session_->CommitConfig();
1086     EXPECT_EQ(intResult, 0);
1087 
1088     sleep(WAIT_TIME_AFTER_START);
1089     intResult = ((sptr<PreviewOutput> &)previewOutput1)->Start();
1090     EXPECT_EQ(intResult, 0);
1091 
1092     sleep(WAIT_TIME_AFTER_START);
1093     intResult = ((sptr<PreviewOutput> &)previewOutput2)->Start();
1094     EXPECT_EQ(intResult, 0);
1095 
1096     sleep(WAIT_TIME_AFTER_START);
1097 
1098     ((sptr<PhotoOutput> &)previewOutput1)->Release();
1099     ((sptr<PhotoOutput> &)previewOutput2)->Release();
1100 }
1101 
1102 /*
1103  * Feature: Framework
1104  * Function: Test capture session with multiple video outputs
1105  * SubFunction: NA
1106  * FunctionPoints: NA
1107  * EnvConditions: NA
1108  * CaseDescription: Test capture session with multiple video ouputs
1109  */
1110 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_026, TestSize.Level0)
1111 {
1112     int32_t intResult = session_->BeginConfig();
1113     EXPECT_EQ(intResult, 0);
1114 
1115     intResult = session_->AddInput(input_);
1116     EXPECT_EQ(intResult, 0);
1117 
1118     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1119     ASSERT_NE(previewOutput, nullptr);
1120 
1121     intResult = session_->AddOutput(previewOutput);
1122     EXPECT_EQ(intResult, 0);
1123 
1124     sptr<CaptureOutput> videoOutput1 = CreateVideoOutput();
1125     ASSERT_NE(videoOutput1, nullptr);
1126 
1127     intResult = session_->AddOutput(videoOutput1);
1128     EXPECT_EQ(intResult, 0);
1129 
1130     sptr<CaptureOutput> videoOutput2 = CreateVideoOutput();
1131     ASSERT_NE(videoOutput2, nullptr);
1132 
1133     intResult = session_->AddOutput(videoOutput2);
1134     EXPECT_EQ(intResult, 0);
1135 
1136     intResult = session_->CommitConfig();
1137     EXPECT_EQ(intResult, 0);
1138 
1139     intResult = session_->Start();
1140     EXPECT_EQ(intResult, 0);
1141     sleep(WAIT_TIME_AFTER_START);
1142     intResult = ((sptr<VideoOutput> &)videoOutput1)->Start();
1143     EXPECT_EQ(intResult, 0);
1144 
1145     intResult = ((sptr<VideoOutput> &)videoOutput2)->Start();
1146     EXPECT_EQ(intResult, 0);
1147 
1148     sleep(WAIT_TIME_AFTER_START);
1149 
1150     intResult = ((sptr<VideoOutput> &)videoOutput1)->Stop();
1151     EXPECT_EQ(intResult, 0);
1152 
1153     intResult = ((sptr<VideoOutput> &)videoOutput2)->Stop();
1154     EXPECT_EQ(intResult, 0);
1155 
1156     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1157 
1158     ((sptr<PreviewOutput> &)previewOutput)->Stop();
1159     session_->Stop();
1160 
1161     ((sptr<PhotoOutput> &)videoOutput1)->Release();
1162     ((sptr<PhotoOutput> &)videoOutput2)->Release();
1163 }
1164 
1165 /*
1166  * Feature: Framework
1167  * Function: Test capture session start and stop preview multiple times
1168  * SubFunction: NA
1169  * FunctionPoints: NA
1170  * EnvConditions: NA
1171  * CaseDescription: Test capture session start and stop preview multiple times
1172  */
1173 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_027, TestSize.Level0)
1174 {
1175     int32_t intResult = session_->BeginConfig();
1176     EXPECT_EQ(intResult, 0);
1177 
1178     intResult = session_->AddInput(input_);
1179     EXPECT_EQ(intResult, 0);
1180 
1181     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1182     ASSERT_NE(previewOutput, nullptr);
1183 
1184     intResult = session_->AddOutput(previewOutput);
1185     EXPECT_EQ(intResult, 0);
1186 
1187     intResult = session_->CommitConfig();
1188     EXPECT_EQ(intResult, 0);
1189 
1190     sleep(WAIT_TIME_AFTER_START);
1191     intResult = ((sptr<PreviewOutput> &)previewOutput)->Start();
1192     EXPECT_EQ(intResult, 0);
1193 
1194     sleep(WAIT_TIME_AFTER_START);
1195 
1196     ((sptr<PreviewOutput> &)previewOutput)->Stop();
1197 
1198     sleep(WAIT_TIME_AFTER_START);
1199 
1200     sleep(WAIT_TIME_AFTER_START);
1201     intResult = ((sptr<PreviewOutput> &)previewOutput)->Start();
1202     EXPECT_EQ(intResult, 0);
1203 
1204     sleep(WAIT_TIME_AFTER_START);
1205 
1206     ((sptr<PreviewOutput> &)previewOutput)->Stop();
1207 }
1208 
1209 /*
1210  * Feature: Framework
1211  * Function: Test capture session start and stop video multiple times
1212  * SubFunction: NA
1213  * FunctionPoints: NA
1214  * EnvConditions: NA
1215  * CaseDescription: Test capture session start and stop video multiple times
1216  */
1217 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_028, TestSize.Level0)
1218 {
1219     int32_t intResult = session_->BeginConfig();
1220     EXPECT_EQ(intResult, 0);
1221 
1222     intResult = session_->AddInput(input_);
1223     EXPECT_EQ(intResult, 0);
1224 
1225     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1226     ASSERT_NE(previewOutput, nullptr);
1227 
1228     intResult = session_->AddOutput(previewOutput);
1229     EXPECT_EQ(intResult, 0);
1230 
1231     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1232     ASSERT_NE(videoOutput, nullptr);
1233 
1234     intResult = session_->AddOutput(videoOutput);
1235     EXPECT_EQ(intResult, 0);
1236 
1237     intResult = session_->CommitConfig();
1238     EXPECT_EQ(intResult, 0);
1239 
1240     intResult = session_->Start();
1241     EXPECT_EQ(intResult, 0);
1242 
1243     sleep(WAIT_TIME_AFTER_START);
1244 
1245     sleep(WAIT_TIME_AFTER_START);
1246 
1247     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1248     EXPECT_EQ(intResult, 0);
1249 
1250     sleep(WAIT_TIME_AFTER_START);
1251 
1252     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1253     EXPECT_EQ(intResult, 0);
1254 
1255     sleep(WAIT_TIME_AFTER_START);
1256 
1257     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1258     EXPECT_EQ(intResult, 0);
1259 
1260     sleep(WAIT_TIME_AFTER_START);
1261 
1262     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1263     EXPECT_EQ(intResult, 0);
1264 
1265     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1266 
1267     sleep(WAIT_TIME_BEFORE_STOP);
1268 
1269     ((sptr<PreviewOutput> &)previewOutput)->Stop();
1270     session_->Stop();
1271 }
1272 
1273 /*
1274  * Feature: Framework
1275  * Function: Test remove video output and commit when preview + video outputs were committed
1276  * SubFunction: NA
1277  * FunctionPoints: NA
1278  * EnvConditions: NA
1279  * CaseDescription: Test remove video output and commit when preview + video outputs were committed
1280  */
1281 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_029, TestSize.Level0)
1282 {
1283     int32_t intResult = session_->BeginConfig();
1284     EXPECT_EQ(intResult, 0);
1285 
1286     intResult = session_->AddInput(input_);
1287     EXPECT_EQ(intResult, 0);
1288 
1289     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1290     ASSERT_NE(previewOutput, nullptr);
1291 
1292     intResult = session_->AddOutput(previewOutput);
1293     EXPECT_EQ(intResult, 0);
1294 
1295     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1296     ASSERT_NE(videoOutput, nullptr);
1297 
1298     intResult = session_->AddOutput(videoOutput);
1299     EXPECT_EQ(intResult, 0);
1300 
1301     intResult = session_->CommitConfig();
1302     EXPECT_EQ(intResult, 0);
1303 
1304     intResult = session_->BeginConfig();
1305     EXPECT_EQ(intResult, 0);
1306 
1307     intResult = session_->RemoveOutput(videoOutput);
1308     EXPECT_EQ(intResult, 0);
1309 
1310     intResult = session_->CommitConfig();
1311     EXPECT_EQ(intResult, 0);
1312 
1313     intResult = session_->Start();
1314     EXPECT_EQ(intResult, 0);
1315 
1316     sleep(WAIT_TIME_AFTER_START);
1317     session_->Stop();
1318 }
1319 
1320 /*
1321  * Feature: Framework
1322  * Function: Test remove video output, add photo output and commit when preview + video outputs were committed
1323  * SubFunction: NA
1324  * FunctionPoints: NA
1325  * EnvConditions: NA
1326  * CaseDescription: Test remove video output, add photo output and commit when preview + video outputs were committed
1327  */
1328 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_030, TestSize.Level0)
1329 {
1330     int32_t intResult = session_->BeginConfig();
1331     EXPECT_EQ(intResult, 0);
1332 
1333     intResult = session_->AddInput(input_);
1334     EXPECT_EQ(intResult, 0);
1335 
1336     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1337     ASSERT_NE(previewOutput, nullptr);
1338 
1339     intResult = session_->AddOutput(previewOutput);
1340     EXPECT_EQ(intResult, 0);
1341 
1342     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1343     ASSERT_NE(videoOutput, nullptr);
1344 
1345     intResult = session_->AddOutput(videoOutput);
1346     EXPECT_EQ(intResult, 0);
1347 
1348     intResult = session_->CommitConfig();
1349     EXPECT_EQ(intResult, 0);
1350 
1351     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1352     ASSERT_NE(photoOutput, nullptr);
1353 
1354     intResult = session_->BeginConfig();
1355     EXPECT_EQ(intResult, 0);
1356 
1357     intResult = session_->RemoveOutput(videoOutput);
1358     EXPECT_EQ(intResult, 0);
1359 
1360     intResult = session_->AddOutput(photoOutput);
1361     EXPECT_EQ(intResult, 0);
1362 
1363     intResult = session_->CommitConfig();
1364     EXPECT_EQ(intResult, 0);
1365 
1366     intResult = session_->Start();
1367     EXPECT_EQ(intResult, 0);
1368 
1369     sleep(WAIT_TIME_AFTER_START);
1370     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture();
1371     EXPECT_EQ(intResult, 0);
1372     sleep(WAIT_TIME_AFTER_CAPTURE);
1373 
1374     session_->Stop();
1375 }
1376 
1377 /*
1378  * Feature: Framework
1379  * Function: Test remove photo output and commit when preview + photo outputs were committed
1380  * SubFunction: NA
1381  * FunctionPoints: NA
1382  * EnvConditions: NA
1383  * CaseDescription: Test remove photo output and commit when preview + photo outputs were committed
1384  */
1385 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_031, TestSize.Level0)
1386 {
1387     int32_t intResult = session_->BeginConfig();
1388     EXPECT_EQ(intResult, 0);
1389 
1390     intResult = session_->AddInput(input_);
1391     EXPECT_EQ(intResult, 0);
1392 
1393     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1394     ASSERT_NE(previewOutput, nullptr);
1395 
1396     intResult = session_->AddOutput(previewOutput);
1397     EXPECT_EQ(intResult, 0);
1398 
1399     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1400     ASSERT_NE(photoOutput, nullptr);
1401 
1402     intResult = session_->AddOutput(photoOutput);
1403     EXPECT_EQ(intResult, 0);
1404 
1405     intResult = session_->CommitConfig();
1406     EXPECT_EQ(intResult, 0);
1407 
1408     intResult = session_->BeginConfig();
1409     EXPECT_EQ(intResult, 0);
1410 
1411     intResult = session_->RemoveOutput(photoOutput);
1412     EXPECT_EQ(intResult, 0);
1413 
1414     intResult = session_->CommitConfig();
1415     EXPECT_EQ(intResult, 0);
1416 
1417     intResult = session_->Start();
1418     EXPECT_EQ(intResult, 0);
1419 
1420     sleep(WAIT_TIME_AFTER_START);
1421 
1422     session_->Stop();
1423 }
1424 
1425 /*
1426  * Feature: Framework
1427  * Function: Test remove photo output, add video output and commit when preview + photo outputs were committed
1428  * SubFunction: NA
1429  * FunctionPoints: NA
1430  * EnvConditions: NA
1431  * CaseDescription: Test remove photo output, add video output and commit when preview + photo outputs were committed
1432  */
1433 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_032, TestSize.Level0)
1434 {
1435     int32_t intResult = session_->BeginConfig();
1436     EXPECT_EQ(intResult, 0);
1437 
1438     intResult = session_->AddInput(input_);
1439     EXPECT_EQ(intResult, 0);
1440 
1441     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1442     ASSERT_NE(previewOutput, nullptr);
1443 
1444     intResult = session_->AddOutput(previewOutput);
1445     EXPECT_EQ(intResult, 0);
1446 
1447     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1448     ASSERT_NE(photoOutput, nullptr);
1449 
1450     intResult = session_->AddOutput(photoOutput);
1451     EXPECT_EQ(intResult, 0);
1452 
1453     intResult = session_->CommitConfig();
1454     EXPECT_EQ(intResult, 0);
1455 
1456     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1457     ASSERT_NE(videoOutput, nullptr);
1458 
1459     intResult = session_->BeginConfig();
1460     EXPECT_EQ(intResult, 0);
1461 
1462     intResult = session_->RemoveOutput(photoOutput);
1463     EXPECT_EQ(intResult, 0);
1464 
1465     intResult = session_->AddOutput(videoOutput);
1466     EXPECT_EQ(intResult, 0);
1467 
1468     intResult = session_->CommitConfig();
1469     EXPECT_EQ(intResult, 0);
1470 
1471     intResult = session_->Start();
1472     EXPECT_EQ(intResult, 0);
1473 
1474     sleep(WAIT_TIME_AFTER_START);
1475 
1476     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1477     EXPECT_EQ(intResult, 0);
1478 
1479     sleep(WAIT_TIME_AFTER_START);
1480 
1481     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1482     EXPECT_EQ(intResult, 0);
1483 
1484     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1485 
1486     sleep(WAIT_TIME_BEFORE_STOP);
1487 
1488     session_->Stop();
1489 }
1490 
1491 /*
1492  * Feature: Framework
1493  * Function: Test capture session remove output with null
1494  * SubFunction: NA
1495  * FunctionPoints: NA
1496  * EnvConditions: NA
1497  * CaseDescription: Test capture session remove output with null
1498  */
1499 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_033, TestSize.Level0)
1500 {
1501     int32_t intResult = session_->BeginConfig();
1502     EXPECT_EQ(intResult, 0);
1503 
1504     sptr<CaptureOutput> output = nullptr;
1505     intResult = session_->RemoveOutput(output);
1506     EXPECT_NE(intResult, 0);
1507 }
1508 
1509 /*
1510  * Feature: Framework
1511  * Function: Test capture session remove input with null
1512  * SubFunction: NA
1513  * FunctionPoints: NA
1514  * EnvConditions: NA
1515  * CaseDescription: Test capture session remove input with null
1516  */
1517 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_034, TestSize.Level0)
1518 {
1519     int32_t intResult = session_->BeginConfig();
1520     EXPECT_EQ(intResult, 0);
1521 
1522     sptr<CaptureInput> input = nullptr;
1523     intResult = session_->RemoveInput(input);
1524     EXPECT_NE(intResult, 0);
1525 }
1526 
1527 /*
1528  * Feature: Framework
1529  * Function: Test Capture with location setting [lat:1 ,long:1 ,alt:1]
1530  * SubFunction: NA
1531  * FunctionPoints: NA
1532  * EnvConditions: NA
1533  * CaseDescription: Test Capture with location setting
1534  */
1535 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_035, TestSize.Level0)
1536 {
1537     std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1538     std::unique_ptr<Location> location = std::make_unique<Location>();
1539     location->latitude = 1;
1540     location->longitude = 1;
1541     location->altitude = 1;
1542 
1543     photoSetting->SetLocation(location);
1544 
1545     int32_t intResult = session_->BeginConfig();
1546     EXPECT_EQ(intResult, 0);
1547 
1548     intResult = session_->AddInput(input_);
1549     EXPECT_EQ(intResult, 0);
1550 
1551     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1552     ASSERT_NE(photoOutput, nullptr);
1553 
1554     intResult = session_->AddOutput(photoOutput);
1555     EXPECT_EQ(intResult, 0);
1556 
1557     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1558     ASSERT_NE(previewOutput, nullptr);
1559 
1560     intResult = session_->AddOutput(previewOutput);
1561     EXPECT_EQ(intResult, 0);
1562 
1563     intResult = session_->CommitConfig();
1564     EXPECT_EQ(intResult, 0);
1565 
1566     intResult = session_->Start();
1567     EXPECT_EQ(intResult, 0);
1568 
1569     sleep(WAIT_TIME_AFTER_START);
1570     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture(photoSetting);
1571     EXPECT_EQ(intResult, 0);
1572     sleep(WAIT_TIME_AFTER_CAPTURE);
1573 
1574     session_->Stop();
1575 }
1576 
1577 /*
1578  * Feature: Framework
1579  * Function: Test Capture with location setting [lat:0.0 ,long:0.0 ,alt:0.0]
1580  * SubFunction: NA
1581  * FunctionPoints: NA
1582  * EnvConditions: NA
1583  * CaseDescription: Test Capture with location setting
1584  */
1585 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_036, TestSize.Level0)
1586 {
1587     std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1588     std::unique_ptr<Location> location = std::make_unique<Location>();
1589     location->latitude = 0.0;
1590     location->longitude = 0.0;
1591     location->altitude = 0.0;
1592 
1593     photoSetting->SetLocation(location);
1594 
1595     int32_t intResult = session_->BeginConfig();
1596     EXPECT_EQ(intResult, 0);
1597 
1598     intResult = session_->AddInput(input_);
1599     EXPECT_EQ(intResult, 0);
1600 
1601     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1602     ASSERT_NE(photoOutput, nullptr);
1603 
1604     intResult = session_->AddOutput(photoOutput);
1605     EXPECT_EQ(intResult, 0);
1606 
1607     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1608     ASSERT_NE(previewOutput, nullptr);
1609 
1610     intResult = session_->AddOutput(previewOutput);
1611     EXPECT_EQ(intResult, 0);
1612 
1613     intResult = session_->CommitConfig();
1614     EXPECT_EQ(intResult, 0);
1615 
1616     intResult = session_->Start();
1617     EXPECT_EQ(intResult, 0);
1618 
1619     sleep(WAIT_TIME_AFTER_START);
1620     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture(photoSetting);
1621     EXPECT_EQ(intResult, 0);
1622     sleep(WAIT_TIME_AFTER_CAPTURE);
1623 
1624     session_->Stop();
1625 }
1626 
1627 /*
1628  * Feature: Framework
1629  * Function: Test Capture with location setting [lat:-1 ,long:-1 ,alt:-1]
1630  * SubFunction: NA
1631  * FunctionPoints: NA
1632  * EnvConditions: NA
1633  * CaseDescription: Test Capture with location setting
1634  */
1635 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_037, TestSize.Level0)
1636 {
1637     std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1638     std::unique_ptr<Location> location = std::make_unique<Location>();
1639     location->latitude = -1;
1640     location->longitude = -1;
1641     location->altitude = -1;
1642 
1643     photoSetting->SetLocation(location);
1644 
1645     int32_t intResult = session_->BeginConfig();
1646     EXPECT_EQ(intResult, 0);
1647 
1648     intResult = session_->AddInput(input_);
1649     EXPECT_EQ(intResult, 0);
1650 
1651     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1652     ASSERT_NE(photoOutput, nullptr);
1653 
1654     intResult = session_->AddOutput(photoOutput);
1655     EXPECT_EQ(intResult, 0);
1656 
1657     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1658     ASSERT_NE(previewOutput, nullptr);
1659 
1660     intResult = session_->AddOutput(previewOutput);
1661     EXPECT_EQ(intResult, 0);
1662 
1663     intResult = session_->CommitConfig();
1664     EXPECT_EQ(intResult, 0);
1665 
1666     intResult = session_->Start();
1667     EXPECT_EQ(intResult, 0);
1668 
1669     sleep(WAIT_TIME_AFTER_START);
1670     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture(photoSetting);
1671     EXPECT_EQ(intResult, 0);
1672     sleep(WAIT_TIME_AFTER_CAPTURE);
1673 
1674     session_->Stop();
1675 }
1676 
1677 /*
1678  * Feature: Framework
1679  * Function: Test snapshot
1680  * SubFunction: NA
1681  * FunctionPoints: NA
1682  * EnvConditions: NA
1683  * CaseDescription: Test snapshot
1684  */
1685 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_038, TestSize.Level0)
1686 {
1687     int32_t intResult = session_->BeginConfig();
1688     EXPECT_EQ(intResult, 0);
1689 
1690     intResult = session_->AddInput(input_);
1691     EXPECT_EQ(intResult, 0);
1692 
1693     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1694     ASSERT_NE(photoOutput, nullptr);
1695 
1696     intResult = session_->AddOutput(photoOutput);
1697     EXPECT_EQ(intResult, 0);
1698 
1699     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1700     ASSERT_NE(previewOutput, nullptr);
1701 
1702     intResult = session_->AddOutput(previewOutput);
1703     EXPECT_EQ(intResult, 0);
1704 
1705     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1706     ASSERT_NE(videoOutput, nullptr);
1707 
1708     intResult = session_->AddOutput(videoOutput);
1709     EXPECT_EQ(intResult, 0);
1710 
1711     intResult = session_->CommitConfig();
1712     EXPECT_EQ(intResult, 0);
1713 
1714     intResult = session_->Start();
1715     EXPECT_EQ(intResult, 0);
1716 
1717     sleep(WAIT_TIME_AFTER_START);
1718 
1719     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1720     EXPECT_EQ(intResult, 0);
1721 
1722     sleep(WAIT_TIME_AFTER_START);
1723     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture();
1724     EXPECT_EQ(intResult, 0);
1725     sleep(WAIT_TIME_AFTER_CAPTURE);
1726 
1727     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1728     EXPECT_EQ(intResult, 0);
1729 
1730     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1731 
1732     sleep(WAIT_TIME_BEFORE_STOP);
1733 
1734     session_->Stop();
1735 }
1736 
1737 /*
1738  * Feature: Framework
1739  * Function: Test snapshot with location setting
1740  * SubFunction: NA
1741  * FunctionPoints: NA
1742  * EnvConditions: NA
1743  * CaseDescription: Test snapshot with location setting
1744  */
1745 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_039, TestSize.Level0)
1746 {
1747     std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1748     std::unique_ptr<Location> location = std::make_unique<Location>();
1749     location->latitude = 12.972442;
1750     location->longitude = 77.580643;
1751     location->altitude = 0;
1752 
1753     int32_t intResult = session_->BeginConfig();
1754     EXPECT_EQ(intResult, 0);
1755 
1756     intResult = session_->AddInput(input_);
1757     EXPECT_EQ(intResult, 0);
1758 
1759     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1760     ASSERT_NE(photoOutput, nullptr);
1761 
1762     intResult = session_->AddOutput(photoOutput);
1763     EXPECT_EQ(intResult, 0);
1764 
1765     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1766     ASSERT_NE(previewOutput, nullptr);
1767 
1768     intResult = session_->AddOutput(previewOutput);
1769     EXPECT_EQ(intResult, 0);
1770 
1771     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1772     ASSERT_NE(videoOutput, nullptr);
1773 
1774     intResult = session_->AddOutput(videoOutput);
1775     EXPECT_EQ(intResult, 0);
1776 
1777     intResult = session_->CommitConfig();
1778     EXPECT_EQ(intResult, 0);
1779 
1780     intResult = session_->Start();
1781     EXPECT_EQ(intResult, 0);
1782 
1783     sleep(WAIT_TIME_AFTER_START);
1784 
1785     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1786     EXPECT_EQ(intResult, 0);
1787 
1788     sleep(WAIT_TIME_AFTER_START);
1789     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture(photoSetting);
1790     EXPECT_EQ(intResult, 0);
1791     sleep(WAIT_TIME_AFTER_CAPTURE);
1792 
1793     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1794     EXPECT_EQ(intResult, 0);
1795 
1796     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1797 
1798     sleep(WAIT_TIME_BEFORE_STOP);
1799 
1800     session_->Stop();
1801 }
1802 
1803 /*
1804  * Feature: Framework
1805  * Function: Test snapshot with mirror setting
1806  * SubFunction: NA
1807  * FunctionPoints: NA
1808  * EnvConditions: NA
1809  * CaseDescription: Test snapshot with mirror setting
1810  */
1811 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_040, TestSize.Level0)
1812 {
1813     std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1814     photoSetting->SetMirror(true);
1815 
1816     int32_t intResult = session_->BeginConfig();
1817     EXPECT_EQ(intResult, 0);
1818 
1819     sptr<CaptureInput> input = manager_->CreateCameraInput(cameras_[1]);
1820     ASSERT_NE(input, nullptr);
1821 
1822     sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1823     camInput->Open();
1824 
1825     intResult = session_->AddInput(input);
1826     EXPECT_EQ(intResult, 0);
1827 
1828     sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
1829     ASSERT_NE(photoOutput, nullptr);
1830 
1831     intResult = session_->AddOutput(photoOutput);
1832     EXPECT_EQ(intResult, 0);
1833 
1834     if (!(((sptr<PhotoOutput> &)photoOutput)->IsMirrorSupported())) {
1835         return;
1836     }
1837 
1838     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1839     ASSERT_NE(previewOutput, nullptr);
1840 
1841     intResult = session_->AddOutput(previewOutput);
1842     EXPECT_EQ(intResult, 0);
1843 
1844     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1845     ASSERT_NE(videoOutput, nullptr);
1846 
1847     intResult = session_->AddOutput(videoOutput);
1848     EXPECT_EQ(intResult, 0);
1849 
1850     intResult = session_->CommitConfig();
1851     EXPECT_EQ(intResult, 0);
1852 
1853     intResult = session_->Start();
1854     EXPECT_EQ(intResult, 0);
1855 
1856     sleep(WAIT_TIME_AFTER_START);
1857 
1858     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1859     EXPECT_EQ(intResult, 0);
1860 
1861     sleep(WAIT_TIME_AFTER_START);
1862     intResult = ((sptr<PhotoOutput> &)photoOutput)->Capture(photoSetting);
1863     EXPECT_EQ(intResult, 0);
1864     sleep(WAIT_TIME_AFTER_CAPTURE);
1865 
1866     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1867     EXPECT_EQ(intResult, 0);
1868 
1869     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1870 
1871     sleep(WAIT_TIME_BEFORE_STOP);
1872 
1873     session_->Stop();
1874 }
1875 
1876 /*
1877  * Feature: Framework
1878  * Function: Test capture session with Video Stabilization Mode
1879  * SubFunction: NA
1880  * FunctionPoints: NA
1881  * EnvConditions: NA
1882  * CaseDescription: Test capture session with Video Stabilization Mode
1883  */
1884 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_042, TestSize.Level0)
1885 {
1886     int32_t intResult = session_->BeginConfig();
1887     EXPECT_EQ(intResult, 0);
1888 
1889     intResult = session_->AddInput(input_);
1890     EXPECT_EQ(intResult, 0);
1891 
1892     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1893     ASSERT_NE(previewOutput, nullptr);
1894 
1895     intResult = session_->AddOutput(previewOutput);
1896     EXPECT_EQ(intResult, 0);
1897 
1898     sptr<CaptureOutput> videoOutput = CreateVideoOutput();
1899     ASSERT_NE(videoOutput, nullptr);
1900 
1901     intResult = session_->AddOutput(videoOutput);
1902     EXPECT_EQ(intResult, 0);
1903 
1904     intResult = session_->CommitConfig();
1905     EXPECT_EQ(intResult, 0);
1906 
1907     std::vector<VideoStabilizationMode> stabilizationmodes = session_->GetSupportedStabilizationMode();
1908     ASSERT_EQ(stabilizationmodes.empty(), false);
1909 
1910     VideoStabilizationMode stabilizationMode = stabilizationmodes.back();
1911     if (session_->IsVideoStabilizationModeSupported(stabilizationMode)) {
1912         session_->SetVideoStabilizationMode(stabilizationMode);
1913         EXPECT_EQ(session_->GetActiveVideoStabilizationMode(), stabilizationMode);
1914     }
1915 
1916     intResult = session_->Start();
1917     EXPECT_EQ(intResult, 0);
1918 
1919     sleep(WAIT_TIME_AFTER_START);
1920 
1921     intResult = ((sptr<VideoOutput> &)videoOutput)->Start();
1922     EXPECT_EQ(intResult, 0);
1923 
1924     sleep(WAIT_TIME_AFTER_START);
1925 
1926     intResult = ((sptr<VideoOutput> &)videoOutput)->Stop();
1927     EXPECT_EQ(intResult, 0);
1928 
1929     TestUtils::SaveVideoFile(nullptr, 0, VideoSaveMode::CLOSE, g_videoFd);
1930 
1931     sleep(WAIT_TIME_BEFORE_STOP);
1932     session_->Stop();
1933 }
1934 
1935 /*
1936  * Feature: Framework
1937  * Function: Test Preview + Metadata
1938  * SubFunction: NA
1939  * FunctionPoints: NA
1940  * EnvConditions: NA
1941  * CaseDescription: Test Preview + Metadata
1942  * @tc.require: SR000GVK5P SR000GVO5O
1943  */
1944 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_043, TestSize.Level0)
1945 {
1946     int32_t intResult = session_->BeginConfig();
1947     EXPECT_EQ(intResult, 0);
1948 
1949     intResult = session_->AddInput(input_);
1950     EXPECT_EQ(intResult, 0);
1951 
1952     sptr<CaptureOutput> previewOutput = CreatePreviewOutput();
1953     ASSERT_NE(previewOutput, nullptr);
1954 
1955     intResult = session_->AddOutput(previewOutput);
1956     EXPECT_EQ(intResult, 0);
1957 
1958     sptr<CaptureOutput> metadatOutput = manager_->CreateMetadataOutput();
1959     ASSERT_NE(metadatOutput, nullptr);
1960 
1961     intResult = session_->AddOutput(metadatOutput);
1962     EXPECT_EQ(intResult, 0);
1963 
1964     sptr<MetadataOutput> metaOutput = (sptr<MetadataOutput> &)metadatOutput;
1965     std::vector<MetadataObjectType> metadataObjectTypes = metaOutput->GetSupportedMetadataObjectTypes();
1966     ASSERT_NE(metadataObjectTypes.size(), 0U);
1967 
1968     metaOutput->SetCapturingMetadataObjectTypes(std::vector<MetadataObjectType> {MetadataObjectType::FACE});
1969 
1970     std::shared_ptr<MetadataObjectCallback> metadataObjectCallback = std::make_shared<AppMetadataCallback>();
1971     metaOutput->SetCallback(metadataObjectCallback);
1972     std::shared_ptr<MetadataStateCallback> metadataStateCallback = std::make_shared<AppMetadataCallback>();
1973     metaOutput->SetCallback(metadataStateCallback);
1974 
1975     intResult = session_->CommitConfig();
1976     EXPECT_EQ(intResult, 0);
1977 
1978     intResult = session_->Start();
1979     EXPECT_EQ(intResult, 0);
1980 
1981     sleep(WAIT_TIME_AFTER_START);
1982 
1983     intResult = metaOutput->Start();
1984     EXPECT_EQ(intResult, 0);
1985 
1986     sleep(WAIT_TIME_AFTER_START);
1987 
1988     intResult = metaOutput->Stop();
1989     EXPECT_EQ(intResult, 0);
1990 
1991     session_->Stop();
1992     metaOutput->Release();
1993 }
1994 
1995 /*
1996  * Feature: Framework
1997  * Function: Test camera preempted.
1998  * SubFunction: NA
1999  * FunctionPoints: NA
2000  * EnvConditions: NA
2001  * CaseDescription: Test camera preempted.
2002  * @tc.require: SR000GVTU0
2003  */
2004 HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_044, TestSize.Level0)
2005 {
2006     std::shared_ptr<AppCallback> callback = std::make_shared<AppCallback>();
2007     sptr<CameraInput> camInput_2 = (sptr<CameraInput> &)input_;
2008     camInput_2->Open();
2009 
2010     camInput_2->SetErrorCallback(callback);
2011 
2012     sptr<CaptureSession> session_2 = manager_->CreateCaptureSession();
2013     ASSERT_NE(session_2, nullptr);
2014 
2015     int32_t intResult = session_2->BeginConfig();
2016     EXPECT_EQ(intResult, 0);
2017 
2018     intResult = session_2->AddInput(input_);
2019     EXPECT_EQ(intResult, 0);
2020 
2021     sptr<CaptureOutput> previewOutput_2 = CreatePreviewOutput();
2022     ASSERT_NE(previewOutput_2, nullptr);
2023 
2024     intResult = session_2->AddOutput(previewOutput_2);
2025     EXPECT_EQ(intResult, 0);
2026 
2027     intResult = session_2->CommitConfig();
2028     EXPECT_EQ(intResult, 0);
2029 
2030     intResult = session_2->Start();
2031     EXPECT_EQ(intResult, 0);
2032 
2033     sleep(WAIT_TIME_AFTER_START);
2034     camInput_2->Close();
2035 
2036     sptr<CaptureInput> input_3 = manager_->CreateCameraInput(cameras_[1]);
2037     ASSERT_NE(input_3, nullptr);
2038 
2039     sptr<CameraInput> camInput_3 = (sptr<CameraInput> &)input_3;
2040     camInput_3->Open();
2041 
2042     sptr<CaptureSession> session_3 = manager_->CreateCaptureSession();
2043     ASSERT_NE(session_3, nullptr);
2044 
2045     intResult = session_3->BeginConfig();
2046     EXPECT_EQ(intResult, 0);
2047 
2048     intResult = session_3->AddInput(input_3);
2049     EXPECT_EQ(intResult, 0);
2050 
2051     sptr<CaptureOutput> previewOutput_3 = CreatePreviewOutput();
2052     ASSERT_NE(previewOutput_3, nullptr);
2053 
2054     intResult = session_3->AddOutput(previewOutput_3);
2055     EXPECT_EQ(intResult, 0);
2056 
2057     intResult = session_3->CommitConfig();
2058     EXPECT_EQ(intResult, 0);
2059 
2060     session_3->Stop();
2061 }
2062 } // CameraStandard
2063 } // OHOS
2064