1 /*
2 * Copyright (c) 2025 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_deferred_photo_moduletest.h"
17 #include "camera_log.h"
18
19 #include "ibuffer_producer.h"
20 #include "iconsumer_surface.h"
21 #include "image_format.h"
22 #include "token_setproc.h"
23 #include "test_token.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace CameraStandard {
29
30 int32_t g_num = 0;
31 const SceneMode CAPTURE_SCENE_MODE = SceneMode::CAPTURE;
32 constexpr int32_t DEFAULT_CAPACITY = 8;
33 constexpr int32_t EXECUTE_SUCCESS = 0;
34 constexpr int32_t EXECUTE_FAILED = -1;
35 constexpr int32_t DEFERRED_PHOTO_NOT_ENABLED = -1;
36 constexpr int32_t DEFERRED_PHOTO_ENABLED = 0;
37 constexpr int32_t PHOTO_CALLBCAK_CNT = 1;
38 constexpr int32_t WAIT_FOR_PHOTO_CB = 8;
39
SetUpTestCase(void)40 void CameraDeferredPhotoModuleTest::SetUpTestCase(void)
41 {
42 MEDIA_INFO_LOG("CameraDeferredPhotoModuleTest::SetUpTestCase is called");
43 ASSERT_TRUE(TestToken().GetAllCameraPermission());
44 }
45
46
TearDownTestCase(void)47 void CameraDeferredPhotoModuleTest::TearDownTestCase(void)
48 {
49 MEDIA_INFO_LOG("CameraDeferredPhotoModuleTest::TearDownTestCase is called");
50 }
51
SetUp()52 void CameraDeferredPhotoModuleTest::SetUp()
53 {
54 g_num++;
55 MEDIA_INFO_LOG("CameraDeferredPhotoModuleTest::SetUp is called, g_num = %{public}d", g_num);
56
57 cameraManager_ = CameraManager::GetInstance();
58 ASSERT_NE(cameraManager_, nullptr);
59
60 cameras_ = cameraManager_->GetSupportedCameras();
61 CHECK_RETURN(cameras_.empty());
62
63 std::vector<SceneMode> sceneModes = GetSupportedSceneModes(cameras_[0]);
64 auto it = std::find(sceneModes.begin(), sceneModes.end(), CAPTURE_SCENE_MODE);
65 CHECK_RETURN(it == sceneModes.end());
66
67 outputCapability_ = cameraManager_->GetSupportedOutputCapability(cameras_[0], CAPTURE_SCENE_MODE);
68 ASSERT_NE(outputCapability_, nullptr);
69 previewProfiles_ = outputCapability_->GetPreviewProfiles();
70 photoProfiles_ = outputCapability_->GetPhotoProfiles();
71 CHECK_RETURN(previewProfiles_.empty() || photoProfiles_.empty());
72
73 previewOutput_ = CreatePreviewOutput(previewProfiles_[0]);
74 ASSERT_NE(previewOutput_, nullptr);
75
76 EXPECT_EQ(CreateAndOpenCameraInput(), EXECUTE_SUCCESS);
77
78 isInitSuccess_ = true;
79 }
80
TearDown()81 void CameraDeferredPhotoModuleTest::TearDown()
82 {
83 MEDIA_INFO_LOG("CameraDeferredPhotoModuleTest::TearDown is called");
84 isInitSuccess_ = false;
85 if (captureSession_) {
86 CHECK_EXECUTE(isSessionStarted_, captureSession_->Stop());
87 if (cameraInput_) {
88 CHECK_EXECUTE(isCameraInputAdded_,
89 captureSession_->RemoveInput(cameraInput_));
90 CHECK_EXECUTE(isCameraInputOpened_, cameraInput_->Close());
91 cameraInput_->Release();
92 }
93 if (previewOutput_) {
94 CHECK_EXECUTE(isPreviewOutputAdded_,
95 captureSession_->RemoveOutput(previewOutput_));
96 previewOutput_->Release();
97 }
98 if (photoOutput_) {
99 sptr<CaptureOutput> output = static_cast<CaptureOutput*>(photoOutput_.GetRefPtr());
100 CHECK_EXECUTE(isPhotoOutputAdded_,
101 captureSession_->RemoveOutput(output));
102 photoOutput_->Release();
103 }
104 captureSession_->Release();
105 }
106
107 isSessionStarted_ = false;
108 isCameraInputOpened_ = false;
109 isCameraInputAdded_ = false;
110 isPreviewOutputAdded_ = false;
111 isPhotoOutputAdded_ = false;
112
113 imageReceiver_.reset();
114 cameras_.clear();
115 previewProfiles_.clear();
116 photoProfiles_.clear();
117 outputCapability_.clear();
118 previewOutput_.clear();
119 photoOutput_.clear();
120 previewSurface_.clear();
121 photoSurface_.clear();
122 photoListener_.clear();
123 cameraInput_.clear();
124 captureSession_.clear();
125 cameraManager_.clear();
126 }
127
GetSupportedSceneModes(sptr<CameraDevice> & camera)128 std::vector<SceneMode> CameraDeferredPhotoModuleTest::GetSupportedSceneModes(sptr<CameraDevice>& camera)
129 {
130 std::vector<SceneMode> sceneModes = {};
131 CHECK_RETURN_RET(cameraManager_ == nullptr, sceneModes);
132 sceneModes = cameraManager_->GetSupportedModes(cameras_[0]);
133 if (sceneModes.empty()) {
134 sceneModes.emplace_back(SceneMode::CAPTURE);
135 sceneModes.emplace_back(SceneMode::VIDEO);
136 }
137 return sceneModes;
138 }
139
CreatePreviewOutput(Profile & previewProfile)140 sptr<CaptureOutput> CameraDeferredPhotoModuleTest::CreatePreviewOutput(Profile& previewProfile)
141 {
142 Size size = previewProfile.GetSize();
143 int32_t width = static_cast<int32_t>(size.width);
144 int32_t height = static_cast<int32_t>(size.height);
145
146 if (imageReceiver_ == nullptr) {
147 imageReceiver_ = Media::ImageReceiver::CreateImageReceiver(width, height,
148 static_cast<int32_t>(Media::ImageFormat::JPEG), DEFAULT_CAPACITY);
149 CHECK_RETURN_RET_ELOG(imageReceiver_ == nullptr, nullptr,
150 "CameraDeferredPhotoModuleTest::CreatePreviewOutput Failed to create image receiver");
151 }
152 std::string surfaceId = imageReceiver_->iraContext_->GetReceiverKey();
153 previewSurface_ = Media::ImageReceiver::getSurfaceById(surfaceId);
154 CHECK_RETURN_RET_ELOG(previewSurface_ == nullptr, nullptr,
155 "CameraDeferredPhotoModuleTest::CreatePreviewOutput Failed to get surface by id");
156 previewSurface_->SetUserData(CameraManager::surfaceFormat, std::to_string(previewProfile.GetCameraFormat()));
157
158 sptr<CaptureOutput> previewOutput;
159 previewOutput = cameraManager_->CreatePreviewOutput(previewProfile, previewSurface_);
160 CHECK_RETURN_RET_ELOG(previewOutput == nullptr, nullptr,
161 "CameraDeferredPhotoModuleTest::CreatePreviewOutput Failed to create preview output");
162
163 return previewOutput;
164 }
165
AddPreviewOutput(sptr<CaptureOutput> & previewOutput)166 int32_t CameraDeferredPhotoModuleTest::AddPreviewOutput(sptr<CaptureOutput>& previewOutput)
167 {
168 CHECK_RETURN_RET(captureSession_ == nullptr, EXECUTE_FAILED);
169 CHECK_RETURN_RET_ELOG(!captureSession_->CanAddOutput(previewOutput), EXECUTE_FAILED,
170 "Can not add preview output");
171 int32_t ret = captureSession_->AddOutput(previewOutput);
172 CHECK_RETURN_RET_ELOG(ret != EXECUTE_SUCCESS, EXECUTE_FAILED, "AddPreviewOutput failed");
173 isPreviewOutputAdded_ = true;
174 return EXECUTE_SUCCESS;
175 }
176
CreateAndOpenCameraInput()177 int32_t CameraDeferredPhotoModuleTest::CreateAndOpenCameraInput()
178 {
179 cameraInput_ = cameraManager_->CreateCameraInput(cameras_[0]);
180 CHECK_RETURN_RET_ELOG(cameraInput_ == nullptr, EXECUTE_FAILED, "CreateCameraInput failed");
181
182 int ret = cameraInput_->Open();
183 CHECK_RETURN_RET_ELOG(ret != EXECUTE_SUCCESS, EXECUTE_FAILED, "CameraInput open failed");
184 isCameraInputOpened_ = true;
185 return EXECUTE_SUCCESS;
186 }
187
AddInput(sptr<CaptureInput> & cameraInput)188 int32_t CameraDeferredPhotoModuleTest::AddInput(sptr<CaptureInput>& cameraInput)
189 {
190 CHECK_RETURN_RET(captureSession_ == nullptr, EXECUTE_FAILED);
191 CHECK_RETURN_RET_ELOG(!captureSession_->CanAddInput(cameraInput), EXECUTE_FAILED, "Can not add input");
192 int32_t ret = captureSession_->AddInput(cameraInput);
193 CHECK_RETURN_RET_ELOG(ret != EXECUTE_SUCCESS, EXECUTE_FAILED, "AddInput failed");
194 isCameraInputAdded_ = true;
195 return EXECUTE_SUCCESS;
196 }
197
CreatePhotoOutputWithoutSurfaceId(Profile & photoProfile)198 sptr<PhotoOutput> CameraDeferredPhotoModuleTest::CreatePhotoOutputWithoutSurfaceId(Profile& photoProfile)
199 {
200 photoSurface_ = Surface::CreateSurfaceAsConsumer("photoOutput");
201 photoSurface_->SetUserData(CameraManager::surfaceFormat, std::to_string(photoProfile.GetCameraFormat()));
202 sptr<IBufferProducer> surfaceProducer = photoSurface_->GetProducer();
203 CHECK_RETURN_RET_ELOG(surfaceProducer == nullptr, nullptr,
204 "CameraDeferredPhotoModuleTest::CreatePhotoOutputWithoutSurfaceId Failed to get producer");
205
206 sptr<PhotoOutput> photoOutput = nullptr;
207 int ret = cameraManager_-> CreatePhotoOutput(photoProfile, surfaceProducer, &photoOutput);
208 EXPECT_EQ(ret, CameraErrorCode::SUCCESS);
209
210 photoOutput->SetNativeSurface(true);
211
212 return photoOutput;
213 }
214
CreatePhotoOutputWithSurfaceId(Profile & photoProfile)215 sptr<PhotoOutput> CameraDeferredPhotoModuleTest::CreatePhotoOutputWithSurfaceId(Profile& photoProfile)
216 {
217 Size size = photoProfile.GetSize();
218 int32_t width = static_cast<int32_t>(size.width);
219 int32_t height = static_cast<int32_t>(size.height);
220
221 if (imageReceiver_ == nullptr) {
222 imageReceiver_ = Media::ImageReceiver::CreateImageReceiver(width, height,
223 static_cast<int32_t>(Media::ImageFormat::JPEG), DEFAULT_CAPACITY);
224 CHECK_RETURN_RET_ELOG(imageReceiver_ == nullptr, nullptr,
225 "CameraDeferredPhotoModuleTest::CreatePhotoOutputWithSurfaceId Failed to create image receiver");
226 }
227 std::string surfaceId = imageReceiver_->iraContext_->GetReceiverKey();
228 photoSurface_ = Media::ImageReceiver::getSurfaceById(surfaceId);
229 CHECK_RETURN_RET_ELOG(photoSurface_ == nullptr, nullptr,
230 "CameraDeferredPhotoModuleTest::CreatePhotoOutputWithSurfaceId Failed to get surface by id");
231 photoSurface_->SetUserData(CameraManager::surfaceFormat, std::to_string(photoProfile.GetCameraFormat()));
232 sptr<IBufferProducer> surfaceProducer = photoSurface_->GetProducer();
233 CHECK_RETURN_RET_ELOG(surfaceProducer == nullptr, nullptr,
234 "CameraDeferredPhotoModuleTest::CreatePhotoOutputWithSurfaceId Failed to get producer");
235
236 sptr<PhotoOutput> photoOutput = nullptr;
237 int ret = cameraManager_-> CreatePhotoOutput(photoProfile, surfaceProducer, &photoOutput);
238 EXPECT_EQ(ret, CameraErrorCode::SUCCESS);
239 return photoOutput;
240 }
241
RegisterPhotoAvailableCallback()242 int32_t CameraDeferredPhotoModuleTest::RegisterPhotoAvailableCallback()
243 {
244 CHECK_RETURN_RET(photoOutput_ == nullptr, EXECUTE_FAILED);
245 photoListener_ = sptr<PhotoListenerModuleTest>::MakeSptr(photoOutput_);
246 CHECK_RETURN_RET_ELOG(photoListener_ == nullptr, EXECUTE_FAILED, "photoListener_ is nullptr");
247 CHECK_RETURN_RET_ELOG(photoSurface_ == nullptr, EXECUTE_FAILED, "photoSurface_ is nullptr");
248 SurfaceError ret = photoSurface_->RegisterConsumerListener((sptr<IBufferConsumerListener>&)photoListener_);
249 CHECK_RETURN_RET_ELOG(ret != SURFACE_ERROR_OK, EXECUTE_FAILED, "RegisterConsumerListener failed");
250
251 auto photoOutput = photoListener_->wPhotoOutput_.promote();
252 CHECK_RETURN_RET_ELOG(photoOutput == nullptr, EXECUTE_FAILED, "wPhotoOutput promote failed");
253 photoOutput->callbackFlag_ |= CAPTURE_PHOTO;
254 photoOutput->SetCallbackFlag(photoOutput->callbackFlag_);
255 return EXECUTE_SUCCESS;
256 }
257
RegisterPhotoAssetAvailableCallback()258 int32_t CameraDeferredPhotoModuleTest::RegisterPhotoAssetAvailableCallback()
259 {
260 CHECK_RETURN_RET(photoOutput_ == nullptr, EXECUTE_FAILED);
261 photoListener_ = sptr<PhotoListenerModuleTest>::MakeSptr(photoOutput_);
262 CHECK_RETURN_RET_ELOG(photoListener_ == nullptr, EXECUTE_FAILED, "photoListener_ is nullptr");
263 CHECK_RETURN_RET_ELOG(photoSurface_ == nullptr, EXECUTE_FAILED, "photoSurface_ is nullptr");
264 SurfaceError ret = photoSurface_->RegisterConsumerListener((sptr<IBufferConsumerListener>&)photoListener_);
265 CHECK_RETURN_RET_ELOG(ret != SURFACE_ERROR_OK, EXECUTE_FAILED, "RegisterConsumerListener failed");
266
267 auto photoOutput = photoListener_->wPhotoOutput_.promote();
268 CHECK_RETURN_RET_ELOG(photoOutput == nullptr, EXECUTE_FAILED, "wPhotoOutput promote failed");
269 photoOutput->callbackFlag_ |= CAPTURE_PHOTO_ASSET;
270 photoOutput->SetCallbackFlag(photoOutput->callbackFlag_);
271
272 return EXECUTE_SUCCESS;
273 }
274
AddPhotoOutput(sptr<PhotoOutput> & photoOutput)275 int32_t CameraDeferredPhotoModuleTest::AddPhotoOutput(sptr<PhotoOutput>& photoOutput)
276 {
277 CHECK_RETURN_RET(captureSession_ == nullptr, EXECUTE_FAILED);
278 sptr<CaptureOutput> output = static_cast<CaptureOutput*>(photoOutput.GetRefPtr());
279 CHECK_RETURN_RET_ELOG(!captureSession_->CanAddOutput(output), EXECUTE_FAILED, "Can not add photo output");
280 int32_t ret = captureSession_->AddOutput(output);
281 CHECK_RETURN_RET_ELOG(ret != EXECUTE_SUCCESS, EXECUTE_FAILED, "AddPhotoOutput failed");
282 isPhotoOutputAdded_ = true;
283 return EXECUTE_SUCCESS;
284 }
285
Start()286 int32_t CameraDeferredPhotoModuleTest::Start()
287 {
288 CHECK_RETURN_RET(captureSession_ == nullptr, EXECUTE_FAILED);
289 int32_t ret = captureSession_->Start();
290 CHECK_RETURN_RET_ELOG(ret != EXECUTE_SUCCESS, EXECUTE_FAILED, "Start capture session failed");
291 isSessionStarted_ = true;
292 return EXECUTE_SUCCESS;
293 }
294
Capture()295 int32_t CameraDeferredPhotoModuleTest::Capture()
296 {
297 CHECK_RETURN_RET(photoOutput_ == nullptr, EXECUTE_FAILED);
298 CHECK_RETURN_RET(!isSessionStarted_, EXECUTE_FAILED);
299 std::shared_ptr<PhotoCaptureSetting> setting = std::make_shared<PhotoCaptureSetting>();
300 CHECK_RETURN_RET_ELOG(setting == nullptr, EXECUTE_FAILED, "setting is nullptr");
301 setting->SetQuality(PhotoCaptureSetting::QualityLevel::QUALITY_LEVEL_HIGH);
302 setting->SetRotation(PhotoCaptureSetting::RotationConfig::Rotation_0);
303 int32_t ret = photoOutput_->Capture(setting);
304 CHECK_RETURN_RET_ELOG(ret != EXECUTE_SUCCESS, EXECUTE_FAILED, "Capture failed");
305 return EXECUTE_SUCCESS;
306 }
307
OnBufferAvailable()308 void PhotoListenerModuleTest::OnBufferAvailable()
309 {
310 std::lock_guard<std::mutex> lock(mtx_);
311 calldeCount_++;
312 MEDIA_INFO_LOG("PhotoListenerModuleTest::OnBufferAvailable is caled, calldeCount_= %{public}d", calldeCount_);
313
314 if (calldeCount_ >= PHOTO_CALLBCAK_CNT) {
315 cv_.notify_all();
316 }
317 }
318
PhotoListenerModuleTest(wptr<PhotoOutput> photoOutput)319 PhotoListenerModuleTest::PhotoListenerModuleTest(wptr<PhotoOutput> photoOutput)
320 {
321 wPhotoOutput_ = photoOutput;
322 calldeCount_ = 0;
323 }
324
WaitForPhotoCallbackAndSetTimeOut()325 void PhotoListenerModuleTest::WaitForPhotoCallbackAndSetTimeOut()
326 {
327 std::unique_lock<std::mutex> lock(mtx_);
328 if (cv_.wait_for(lock, std::chrono::seconds(WAIT_FOR_PHOTO_CB), [this] {
329 return this->calldeCount_ >= PHOTO_CALLBCAK_CNT;
330 })) {
331 MEDIA_INFO_LOG("photo callback is called, calldeCount_ = %{public}d", calldeCount_);
332 } else {
333 MEDIA_ERR_LOG("[TIMEOUT] photo callback is not called, calldeCount_ = %{public}d", calldeCount_);
334 }
335 }
336
337 /*
338 * Feature: Framework
339 * Function: Test default enabling deferred photo.
340 * SubFunction: NA
341 * FunctionPoints: NA
342 * EnvConditions: NA
343 * CaseDescription: Verify the deferred photo is enabled by default in normal conditions after registering photo asset
344 * available listener.
345 */
346 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_001, TestSize.Level1)
347 {
348 CHECK_RETURN(!isInitSuccess_);
349 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
350 ASSERT_NE(photoOutput_, nullptr);
351
352 int32_t ret = RegisterPhotoAssetAvailableCallback();
353 EXPECT_EQ(ret, EXECUTE_SUCCESS);
354
355 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
356 ASSERT_NE(captureSession_, nullptr);
357
358 ret = captureSession_->BeginConfig();
359 EXPECT_EQ(ret, EXECUTE_SUCCESS);
360
361 ret = AddInput(cameraInput_);
362 EXPECT_EQ(ret, EXECUTE_SUCCESS);
363
364 ret = AddPreviewOutput(previewOutput_);
365 EXPECT_EQ(ret, EXECUTE_SUCCESS);
366
367 ret = AddPhotoOutput(photoOutput_);
368 EXPECT_EQ(ret, EXECUTE_SUCCESS);
369
370 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
371 CHECK_RETURN(ret != 0);
372
373 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
374 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
375
376 ret = captureSession_->CommitConfig();
377 EXPECT_EQ(ret, EXECUTE_SUCCESS);
378
379 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
380 EXPECT_EQ(ret, DEFERRED_PHOTO_ENABLED);
381
382 ret = Start();
383 EXPECT_EQ(ret, EXECUTE_SUCCESS);
384
385 ret = Capture();
386 EXPECT_EQ(ret, EXECUTE_SUCCESS);
387
388 photoListener_->WaitForPhotoCallbackAndSetTimeOut();
389 EXPECT_EQ(photoListener_->calldeCount_, PHOTO_CALLBCAK_CNT);
390 }
391
392 /*
393 * Feature: Framework
394 * Function: Test default enabling deferred photo.
395 * SubFunction: NA
396 * FunctionPoints: NA
397 * EnvConditions: NA
398 * CaseDescription: Verify the deferred photo is enabled by default, neither registering photo asset available
399 * listener nor photo available listener.
400 */
401 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_002, TestSize.Level0)
402 {
403 CHECK_RETURN(!isInitSuccess_);
404 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
405 ASSERT_NE(photoOutput_, nullptr);
406
407 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
408 ASSERT_NE(captureSession_, nullptr);
409
410 int32_t ret = captureSession_->BeginConfig();
411 EXPECT_EQ(ret, EXECUTE_SUCCESS);
412
413 ret = AddInput(cameraInput_);
414 EXPECT_EQ(ret, EXECUTE_SUCCESS);
415
416 ret = AddPreviewOutput(previewOutput_);
417 EXPECT_EQ(ret, EXECUTE_SUCCESS);
418
419 ret = AddPhotoOutput(photoOutput_);
420 EXPECT_EQ(ret, EXECUTE_SUCCESS);
421
422 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
423 CHECK_RETURN(ret != 0);
424
425 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
426 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
427
428 ret = captureSession_->CommitConfig();
429 EXPECT_EQ(ret, EXECUTE_SUCCESS);
430
431 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
432 EXPECT_EQ(ret, DEFERRED_PHOTO_ENABLED);
433
434 ret = Start();
435 EXPECT_EQ(ret, EXECUTE_SUCCESS);
436
437 ret = Capture();
438 EXPECT_EQ(ret, EXECUTE_SUCCESS);
439 }
440
441 /*
442 * Feature: Framework
443 * Function: Test default enabling deferred photo in abnormal conditions.
444 * SubFunction: NA
445 * FunctionPoints: NA
446 * EnvConditions: NA
447 * CaseDescription: Verify the deferred photo is not enabled by default under the abnormal condition, registering
448 * photo available listener only.
449 */
450 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_003, TestSize.Level0)
451 {
452 CHECK_RETURN(!isInitSuccess_);
453 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
454 ASSERT_NE(photoOutput_, nullptr);
455
456 int32_t ret = RegisterPhotoAvailableCallback();
457 EXPECT_EQ(ret, EXECUTE_SUCCESS);
458
459 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
460 ASSERT_NE(captureSession_, nullptr);
461
462 ret = captureSession_->BeginConfig();
463 EXPECT_EQ(ret, EXECUTE_SUCCESS);
464
465 ret = AddInput(cameraInput_);
466 EXPECT_EQ(ret, EXECUTE_SUCCESS);
467
468 ret = AddPreviewOutput(previewOutput_);
469 EXPECT_EQ(ret, EXECUTE_SUCCESS);
470
471 ret = AddPhotoOutput(photoOutput_);
472 EXPECT_EQ(ret, EXECUTE_SUCCESS);
473
474 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
475 CHECK_RETURN(ret != 0);
476
477 ret = captureSession_->CommitConfig();
478 EXPECT_EQ(ret, EXECUTE_SUCCESS);
479
480 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
481 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
482
483 ret = Start();
484 EXPECT_EQ(ret, EXECUTE_SUCCESS);
485 }
486
487 /*
488 * Feature: Framework
489 * Function: Test default enabling deferred photo in abnormal conditions.
490 * SubFunction: NA
491 * FunctionPoints: NA
492 * EnvConditions: NA
493 * CaseDescription: Verify the deferred photo is not enabled by default under the abnormal condition, creating photo
494 * output with surface id.
495 */
496 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_004, TestSize.Level0)
497 {
498 CHECK_RETURN(!isInitSuccess_);
499 photoOutput_ = CreatePhotoOutputWithSurfaceId(photoProfiles_[0]);
500 ASSERT_NE(photoOutput_, nullptr);
501
502 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
503 ASSERT_NE(captureSession_, nullptr);
504
505 int32_t ret = captureSession_->BeginConfig();
506 EXPECT_EQ(ret, EXECUTE_SUCCESS);
507
508 ret = AddInput(cameraInput_);
509 EXPECT_EQ(ret, EXECUTE_SUCCESS);
510
511 ret = AddPreviewOutput(previewOutput_);
512 EXPECT_EQ(ret, EXECUTE_SUCCESS);
513
514 ret = AddPhotoOutput(photoOutput_);
515 EXPECT_EQ(ret, EXECUTE_SUCCESS);
516
517 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
518 CHECK_RETURN(ret != 0);
519
520 ret = captureSession_->CommitConfig();
521 EXPECT_EQ(ret, EXECUTE_SUCCESS);
522
523 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
524 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
525
526 ret = Start();
527 EXPECT_EQ(ret, EXECUTE_SUCCESS);
528 }
529
530 /*
531 * Feature: Framework
532 * Function: Test default enabling deferred photo in abnormal conditions.
533 * SubFunction: NA
534 * FunctionPoints: NA
535 * EnvConditions: NA
536 * CaseDescription: Verify the deferred photo is not enabled by default under the abnormal condition, enabling
537 * DELIVERY_NONE type in advance.
538 */
539 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_005, TestSize.Level0)
540 {
541 CHECK_RETURN(!isInitSuccess_);
542 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
543 ASSERT_NE(photoOutput_, nullptr);
544
545 int32_t ret = RegisterPhotoAssetAvailableCallback();
546 EXPECT_EQ(ret, EXECUTE_SUCCESS);
547
548 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
549 ASSERT_NE(captureSession_, nullptr);
550
551 ret = captureSession_->BeginConfig();
552 EXPECT_EQ(ret, EXECUTE_SUCCESS);
553
554 ret = AddInput(cameraInput_);
555 EXPECT_EQ(ret, EXECUTE_SUCCESS);
556
557 ret = AddPreviewOutput(previewOutput_);
558 EXPECT_EQ(ret, EXECUTE_SUCCESS);
559
560 ret = AddPhotoOutput(photoOutput_);
561 EXPECT_EQ(ret, EXECUTE_SUCCESS);
562
563 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
564 CHECK_RETURN(ret != 0);
565
566 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_NONE);
567 CHECK_RETURN(ret != 0);
568
569 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_NONE);
570 EXPECT_EQ(ret, EXECUTE_SUCCESS);
571
572 ret = captureSession_->CommitConfig();
573 EXPECT_EQ(ret, EXECUTE_SUCCESS);
574
575 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
576 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
577
578 ret = Start();
579 EXPECT_EQ(ret, EXECUTE_SUCCESS);
580 }
581
582 /*
583 * Feature: Framework
584 * Function: Test default enabling deferred photo in abnormal conditions.
585 * SubFunction: NA
586 * FunctionPoints: NA
587 * EnvConditions: NA
588 * CaseDescription: Verify the deferred photo is not enabled by default under the abnormal condition, enabling
589 * DELIVERY_VIDEO type in advance.
590 */
591 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_006, TestSize.Level0)
592 {
593 CHECK_RETURN(!isInitSuccess_);
594 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
595 ASSERT_NE(photoOutput_, nullptr);
596
597 int32_t ret = RegisterPhotoAssetAvailableCallback();
598 EXPECT_EQ(ret, EXECUTE_SUCCESS);
599
600 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
601 ASSERT_NE(captureSession_, nullptr);
602
603 ret = captureSession_->BeginConfig();
604 EXPECT_EQ(ret, EXECUTE_SUCCESS);
605
606 ret = AddInput(cameraInput_);
607 EXPECT_EQ(ret, EXECUTE_SUCCESS);
608
609 ret = AddPreviewOutput(previewOutput_);
610 EXPECT_EQ(ret, EXECUTE_SUCCESS);
611
612 ret = AddPhotoOutput(photoOutput_);
613 EXPECT_EQ(ret, EXECUTE_SUCCESS);
614
615 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
616 CHECK_RETURN(ret != 0);
617
618 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_VIDEO);
619 CHECK_RETURN(ret != 0);
620
621 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_VIDEO);
622 EXPECT_EQ(ret, EXECUTE_SUCCESS);
623
624 ret = captureSession_->CommitConfig();
625 EXPECT_EQ(ret, EXECUTE_SUCCESS);
626
627 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
628 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
629
630 ret = Start();
631 EXPECT_EQ(ret, EXECUTE_SUCCESS);
632 }
633
634 /*
635 * Feature: Framework
636 * Function: Test active enabling deferred photo in normal conditions.
637 * SubFunction: NA
638 * FunctionPoints: NA
639 * EnvConditions: NA
640 * CaseDescription: Verify the deferred photo is enabled in normal conditions.
641 */
642 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_007, TestSize.Level1)
643 {
644 CHECK_RETURN(!isInitSuccess_);
645 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
646 ASSERT_NE(photoOutput_, nullptr);
647
648 int32_t ret = RegisterPhotoAssetAvailableCallback();
649 EXPECT_EQ(ret, EXECUTE_SUCCESS);
650
651 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
652 ASSERT_NE(captureSession_, nullptr);
653
654 ret = captureSession_->BeginConfig();
655 EXPECT_EQ(ret, EXECUTE_SUCCESS);
656
657 ret = AddInput(cameraInput_);
658 EXPECT_EQ(ret, EXECUTE_SUCCESS);
659
660 ret = AddPreviewOutput(previewOutput_);
661 EXPECT_EQ(ret, EXECUTE_SUCCESS);
662
663 ret = AddPhotoOutput(photoOutput_);
664 EXPECT_EQ(ret, EXECUTE_SUCCESS);
665
666 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
667 CHECK_RETURN(ret != 0);
668
669 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
670 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
671
672 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_PHOTO);
673 EXPECT_EQ(ret, EXECUTE_SUCCESS);
674
675 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
676 EXPECT_EQ(ret, DEFERRED_PHOTO_ENABLED);
677
678 ret = captureSession_->CommitConfig();
679 EXPECT_EQ(ret, EXECUTE_SUCCESS);
680
681 ret = Start();
682 EXPECT_EQ(ret, EXECUTE_SUCCESS);
683
684 ret = Capture();
685 EXPECT_EQ(ret, EXECUTE_SUCCESS);
686
687 photoListener_->WaitForPhotoCallbackAndSetTimeOut();
688 EXPECT_EQ(photoListener_->calldeCount_, PHOTO_CALLBCAK_CNT);
689 }
690
691 /*
692 * Feature: Framework
693 * Function: Test active enabling deferred photo in abnormal conditions.
694 * SubFunction: NA
695 * FunctionPoints: NA
696 * EnvConditions: NA
697 * CaseDescription: Verify the deferred photo is not enabled under the abnormal condition, enabling before AddInput.
698 */
699 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_008, TestSize.Level0)
700 {
701 CHECK_RETURN(!isInitSuccess_);
702 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
703 ASSERT_NE(photoOutput_, nullptr);
704
705 int32_t ret = RegisterPhotoAssetAvailableCallback();
706 EXPECT_EQ(ret, EXECUTE_SUCCESS);
707
708 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
709 ASSERT_NE(captureSession_, nullptr);
710
711 ret = captureSession_->BeginConfig();
712 EXPECT_EQ(ret, EXECUTE_SUCCESS);
713
714 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
715 EXPECT_EQ(ret, CameraErrorCode::SESSION_NOT_RUNNING);
716
717 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_PHOTO);
718 EXPECT_EQ(ret, CameraErrorCode::SESSION_NOT_RUNNING);
719
720 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
721 EXPECT_EQ(ret, CameraErrorCode::SESSION_NOT_RUNNING);
722
723 ret = AddInput(cameraInput_);
724 EXPECT_EQ(ret, EXECUTE_SUCCESS);
725
726 ret = AddPreviewOutput(previewOutput_);
727 EXPECT_EQ(ret, EXECUTE_SUCCESS);
728
729 ret = AddPhotoOutput(photoOutput_);
730 EXPECT_EQ(ret, EXECUTE_SUCCESS);
731
732 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
733 CHECK_RETURN(ret != 0);
734
735 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
736 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
737
738 ret = captureSession_->CommitConfig();
739 EXPECT_EQ(ret, EXECUTE_SUCCESS);
740
741 ret = Start();
742 EXPECT_EQ(ret, EXECUTE_SUCCESS);
743 }
744
745 /*
746 * Feature: Framework
747 * Function: Test active enabling deferred photo in abnormal conditions.
748 * SubFunction: NA
749 * FunctionPoints: NA
750 * EnvConditions: NA
751 * CaseDescription: Verify the deferred photo is not enabled under the abnormal condition, enabling after AddInput but
752 * before AddPhotoOoutput.
753 */
754 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_009, TestSize.Level0)
755 {
756 CHECK_RETURN(!isInitSuccess_);
757 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
758 ASSERT_NE(photoOutput_, nullptr);
759
760 int32_t ret = RegisterPhotoAssetAvailableCallback();
761 EXPECT_EQ(ret, EXECUTE_SUCCESS);
762
763 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
764 ASSERT_NE(captureSession_, nullptr);
765
766 ret = captureSession_->BeginConfig();
767 EXPECT_EQ(ret, EXECUTE_SUCCESS);
768
769 ret = AddInput(cameraInput_);
770 EXPECT_EQ(ret, EXECUTE_SUCCESS);
771
772 ret = AddPreviewOutput(previewOutput_);
773 EXPECT_EQ(ret, EXECUTE_SUCCESS);
774
775 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
776 EXPECT_EQ(ret, CameraErrorCode::SESSION_NOT_RUNNING);
777
778 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_PHOTO);
779 EXPECT_EQ(ret, CameraErrorCode::SESSION_NOT_RUNNING);
780
781 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
782 EXPECT_EQ(ret, CameraErrorCode::SESSION_NOT_RUNNING);
783
784 ret = AddPhotoOutput(photoOutput_);
785 EXPECT_EQ(ret, EXECUTE_SUCCESS);
786
787 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
788 CHECK_RETURN(ret != 0);
789
790 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
791 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
792
793 ret = captureSession_->CommitConfig();
794 EXPECT_EQ(ret, EXECUTE_SUCCESS);
795
796 ret = Start();
797 EXPECT_EQ(ret, EXECUTE_SUCCESS);
798 }
799
800 /*
801 * Feature: Framework
802 * Function: Test active enabling deferred photo in abnormal conditions.
803 * SubFunction: NA
804 * FunctionPoints: NA
805 * EnvConditions: NA
806 * CaseDescription: Verify the deferred photo is not enabled under the abnormal condition, enabling after CommitConfig,
807 * when default enabling is turned off by enabling DELIVERY_NONE type in advance.
808 */
809 HWTEST_F(CameraDeferredPhotoModuleTest, camera_deferred_photo_moduletest_010, TestSize.Level0)
810 {
811 CHECK_RETURN(!isInitSuccess_);
812 photoOutput_ = CreatePhotoOutputWithoutSurfaceId(photoProfiles_[0]);
813 ASSERT_NE(photoOutput_, nullptr);
814
815 int32_t ret = RegisterPhotoAssetAvailableCallback();
816 EXPECT_EQ(ret, EXECUTE_SUCCESS);
817
818 captureSession_ = cameraManager_->CreateCaptureSession(CAPTURE_SCENE_MODE);
819 ASSERT_NE(captureSession_, nullptr);
820
821 ret = captureSession_->BeginConfig();
822 EXPECT_EQ(ret, EXECUTE_SUCCESS);
823
824 ret = AddInput(cameraInput_);
825 EXPECT_EQ(ret, EXECUTE_SUCCESS);
826
827 ret = AddPreviewOutput(previewOutput_);
828 EXPECT_EQ(ret, EXECUTE_SUCCESS);
829
830 ret = AddPhotoOutput(photoOutput_);
831 EXPECT_EQ(ret, EXECUTE_SUCCESS);
832
833 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_PHOTO);
834 CHECK_RETURN(ret != 0);
835
836 ret = photoOutput_->IsDeferredImageDeliverySupported(DELIVERY_NONE);
837 CHECK_RETURN(ret != 0);
838
839 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_NONE);
840 EXPECT_EQ(ret, EXECUTE_SUCCESS);
841
842 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
843 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
844
845 ret = captureSession_->CommitConfig();
846 EXPECT_EQ(ret, EXECUTE_SUCCESS);
847
848 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
849 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
850
851 ret = photoOutput_->DeferImageDeliveryFor(DELIVERY_PHOTO);
852 EXPECT_EQ(ret, EXECUTE_SUCCESS);
853
854 ret = photoOutput_->IsDeferredImageDeliveryEnabled(DELIVERY_PHOTO);
855 EXPECT_EQ(ret, DEFERRED_PHOTO_NOT_ENABLED);
856
857 ret = Start();
858 EXPECT_EQ(ret, EXECUTE_SUCCESS);
859 }
860 } // namespace CameraStandard
861 } // namespace OHOS