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_photo_moduletest.h"
17
18 #include "accesstoken_kit.h"
19 #include "hap_token_info.h"
20 #include "nativetoken_kit.h"
21 #include "ipc_skeleton.h"
22 #include "os_account_manager.h"
23 #include "token_setproc.h"
24 #include "camera_log.h"
25 #include "test_token.h"
26
27
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace CameraStandard {
32 static std::mutex g_mutex;
33
SetUpTestCase(void)34 void CameraPhotoModuleTest::SetUpTestCase(void)
35 {
36 MEDIA_DEBUG_LOG("CameraPhotoModuleTest::SetUpTestCase started!");
37 ASSERT_TRUE(TestToken().GetAllCameraPermission());
38 }
39
TearDownTestCase(void)40 void CameraPhotoModuleTest::TearDownTestCase(void)
41 {
42 MEDIA_DEBUG_LOG("CameraPhotoModuleTest::TearDownTestCase started!");
43 }
44
SetUp()45 void CameraPhotoModuleTest::SetUp()
46 {
47 MEDIA_INFO_LOG("CameraPhotoModuleTest::SetUp start!");
48
49 manager_ = CameraManager::GetInstance();
50 ASSERT_NE(manager_, nullptr);
51 cameras_ = manager_->GetSupportedCameras();
52 ASSERT_FALSE(cameras_.empty());
53 session_ = manager_->CreateCaptureSession(SceneMode::CAPTURE);
54 ASSERT_NE(session_, nullptr);
55 input_ = manager_->CreateCameraInput(cameras_[0]);
56 ASSERT_NE(input_, nullptr);
57 EXPECT_EQ(input_->Open(), SUCCESS);
58 UpdateCameraOutputCapability();
59 MEDIA_INFO_LOG("CameraPhotoModuleTest::SetUp end!");
60 }
61
TearDown()62 void CameraPhotoModuleTest::TearDown()
63 {
64 MEDIA_INFO_LOG("CameraPhotoModuleTest::TearDown start!");
65
66 cameras_.clear();
67 photoProfile_.clear();
68 previewProfile_.clear();
69
70 photoOutput_->Release();
71 previewOutput_->Release();
72
73 manager_ = nullptr;
74 input_->Release();
75 session_->Release();
76 previewSurface_ = nullptr;
77 MEDIA_INFO_LOG("CameraPhotoModuleTest::TearDown end!");
78 }
79
UpdateCameraOutputCapability(int32_t modeName)80 void CameraPhotoModuleTest::UpdateCameraOutputCapability(int32_t modeName)
81 {
82 if (!manager_ || cameras_.empty()) {
83 return;
84 }
85 auto outputCapability = manager_->GetSupportedOutputCapability(cameras_[0], modeName);
86 ASSERT_NE(outputCapability, nullptr);
87
88 previewProfile_ = outputCapability->GetPreviewProfiles();
89 ASSERT_FALSE(previewProfile_.empty());
90
91 photoProfile_ = outputCapability->GetPhotoProfiles();
92 ASSERT_FALSE(photoProfile_.empty());
93 }
94
CreatePreviewOutput(Profile & profile,sptr<PreviewOutput> & previewOutput)95 int32_t CameraPhotoModuleTest::CreatePreviewOutput(Profile &profile, sptr<PreviewOutput> &previewOutput)
96 {
97 previewSurface_ = Surface::CreateSurfaceAsConsumer();
98 if (previewSurface_ == nullptr) {
99 MEDIA_ERR_LOG("Failed to get previewOutput surface");
100 return INVALID_ARGUMENT;
101 }
102 previewSurface_->SetUserData(CameraManager::surfaceFormat, std::to_string(profile.GetCameraFormat()));
103 previewListener_ = nullptr;
104 previewListener_ = new (std::nothrow) TestPreviewConsumer(previewSurface_);
105 SurfaceError ret = previewSurface_->RegisterConsumerListener((sptr<IBufferConsumerListener> &)previewListener_);
106 EXPECT_EQ(ret, SURFACE_ERROR_OK);
107 int32_t retCode = manager_->CreatePreviewOutput(profile, previewSurface_, &previewOutput);
108 if (retCode != CameraErrorCode::SUCCESS) {
109 return SERVICE_FATL_ERROR;
110 }
111 return SUCCESS;
112 }
113
CreatePhotoOutputWithoutSurface(Profile & profile,sptr<PhotoOutput> & photoOutput)114 int32_t CameraPhotoModuleTest::CreatePhotoOutputWithoutSurface(Profile &profile, sptr<PhotoOutput> &photoOutput)
115 {
116 int32_t retCode = manager_->CreatePhotoOutput(profile, &photoOutput);
117 CHECK_RETURN_RET_ELOG((retCode != CameraErrorCode::SUCCESS || photoOutput == nullptr), SERVICE_FATL_ERROR,
118 "Create photo output failed");
119
120 photoOutput->SetNativeSurface(true);
121 return SUCCESS;
122 }
123
CreateYuvPhotoOutput()124 int32_t CameraPhotoModuleTest::CreateYuvPhotoOutput()
125 {
126 for (Profile &profile : photoProfile_) {
127 if (profile.GetCameraFormat() == CAMERA_FORMAT_YUV_420_SP) {
128 yuvPhotoProfile_ = profile;
129 std::cout << "get profle:" << profile.GetCameraFormat() << " width:" << profile.GetSize().width
130 << "height:" << profile.GetSize().height << std::endl;
131 break;
132 } else {
133 std::cout << "skip profle:" << profile.GetCameraFormat() << " width:" << profile.GetSize().width
134 << "height:" << profile.GetSize().height << std::endl;
135 }
136 }
137 int32_t retCode = manager_->CreatePhotoOutput(yuvPhotoProfile_, &photoOutput_);
138 CHECK_RETURN_RET_ELOG((retCode != CameraErrorCode::SUCCESS || photoOutput_ == nullptr),
139 SERVICE_FATL_ERROR,
140 "Create photo output failed");
141
142 photoOutput_->SetNativeSurface(true);
143 return SUCCESS;
144 }
145
CreateYuvPreviewOutput()146 int32_t CameraPhotoModuleTest::CreateYuvPreviewOutput()
147 {
148 Profile yuvProfile;
149 std::cout << "photo yuv profle format:" << yuvPhotoProfile_.GetCameraFormat()
150 << " width:" << yuvPhotoProfile_.GetSize().width << " height:" << yuvPhotoProfile_.GetSize().height
151 << std::endl;
152 for (Profile &profile : previewProfile_) {
153 float ratio1 = static_cast<float>(yuvPhotoProfile_.GetSize().width) / yuvPhotoProfile_.GetSize().height;
154 float ratio2 = static_cast<float>(profile.GetSize().width) / profile.GetSize().height;
155 std::cout << "ratio1:" << ratio1 << " ratio2:" << ratio2 << std::endl;
156 if (profile.GetCameraFormat() == CAMERA_FORMAT_YUV_420_SP && ratio1 == ratio2) {
157 yuvProfile = profile;
158 std::cout << "get profle:" << profile.GetCameraFormat() << " width:" << profile.GetSize().width
159 << " height:" << profile.GetSize().height << std::endl;
160 break;
161 } else {
162 std::cout << "skip profle:" << profile.GetCameraFormat() << " width:" << profile.GetSize().width
163 << " height:" << profile.GetSize().height << std::endl;
164 }
165 }
166
167 int32_t retCode = CreatePreviewOutput(yuvProfile, previewOutput_);
168 CHECK_RETURN_RET_ELOG((retCode != CameraErrorCode::SUCCESS || previewOutput_ == nullptr),
169 SERVICE_FATL_ERROR,
170 "Create preview output failed");
171
172 photoOutput_->SetNativeSurface(true);
173 return SUCCESS;
174 }
175
TestPreviewConsumer(wptr<Surface> surface)176 TestPreviewConsumer::TestPreviewConsumer(wptr<Surface> surface) : surface_(surface)
177 {
178 MEDIA_INFO_LOG("TestPreviewConsumer new E");
179 }
180
~TestPreviewConsumer()181 TestPreviewConsumer::~TestPreviewConsumer()
182 {
183 MEDIA_INFO_LOG("TestPreviewConsumer ~ E");
184 }
185
OnBufferAvailable()186 void TestPreviewConsumer::OnBufferAvailable()
187 {
188 MEDIA_INFO_LOG("TestPreviewConsumer OnBufferAvailable E");
189 CAMERA_SYNC_TRACE;
190 sptr<Surface> surface = surface_.promote();
191 CHECK_RETURN_ELOG(surface == nullptr, "surface is null");
192 sptr<SurfaceBuffer> surfaceBuffer = nullptr;
193 int32_t fence = -1;
194 int64_t timestamp;
195 OHOS::Rect damage;
196 SurfaceError surfaceRet = surface_->AcquireBuffer(surfaceBuffer, fence, timestamp, damage);
197 CHECK_RETURN_ELOG(surfaceRet != SURFACE_ERROR_OK, "Failed to acquire surface buffer");
198 surfaceRet = surface_->ReleaseBuffer(surfaceBuffer, -1);
199 MEDIA_INFO_LOG("TestPreviewConsumer OnBufferAvailable X");
200 }
201
OnPhotoAvailable(const std::shared_ptr<Media::NativeImage> nativeImage,bool isRaw) const202 void TestCaptureCallback::OnPhotoAvailable(const std::shared_ptr<Media::NativeImage> nativeImage, bool isRaw) const
203 {
204 MEDIA_DEBUG_LOG("TestCaptureCallback::OnPhotoAvailable is called!");
205 photoFlag_ = true;
206 }
207
OnPhotoAssetAvailable(const int32_t captureId,const std::string & uri,int32_t cameraShotType,const std::string & burstKey) const208 void TestCaptureCallback::OnPhotoAssetAvailable(
209 const int32_t captureId, const std::string &uri, int32_t cameraShotType, const std::string &burstKey) const
210 {
211 MEDIA_DEBUG_LOG("TestCaptureCallback::OnPhotoAssetAvailable is called!");
212 photoAssetFlag_ = true;
213 }
214
OnThumbnailAvailable(int32_t captureId,int64_t timestamp,std::unique_ptr<Media::PixelMap> pixelMap) const215 void TestCaptureCallback::OnThumbnailAvailable(
216 int32_t captureId, int64_t timestamp, std::unique_ptr<Media::PixelMap> pixelMap) const
217 {
218 MEDIA_DEBUG_LOG("TestCaptureCallback::OnThumbnailAvailable is called!");
219 thumbnailFlag_ = true;
220 }
221
222 /*
223 * Feature: Framework
224 * Function: Test the photo available callback
225 * SubFunction: NA
226 * FunctionPoints: NA
227 * EnvConditions: NA
228 * CaseDescription: Test the photo available callback, when capture is ok.
229 */
230 HWTEST_F(CameraPhotoModuleTest, camera_photo_moduletest_001, TestSize.Level0)
231 {
232 EXPECT_EQ(CreatePreviewOutput(previewProfile_[0], previewOutput_), SUCCESS);
233 EXPECT_EQ(CreatePhotoOutputWithoutSurface(photoProfile_[0], photoOutput_), SUCCESS);
234 EXPECT_EQ(session_->BeginConfig(), SUCCESS);
235 EXPECT_EQ(session_->AddInput((sptr<CaptureInput>&)input_), SUCCESS);
236 EXPECT_EQ(session_->AddOutput((sptr<CaptureOutput>&)previewOutput_), SUCCESS);
237 EXPECT_EQ(session_->AddOutput((sptr<CaptureOutput>&)photoOutput_), SUCCESS);
238
239 std::shared_ptr<TestCaptureCallback> callback = std::make_shared<TestCaptureCallback>();
240 photoOutput_->SetPhotoAvailableCallback(callback);
241 callbackFlag_ |= CAPTURE_PHOTO;
242 photoOutput_->SetCallbackFlag(callbackFlag_);
243
244 EXPECT_EQ(session_->CommitConfig(), SUCCESS);
245 EXPECT_EQ(session_->Start(), SUCCESS);
246 sleep(WAIT_TIME_AFTER_START);
247
248 EXPECT_EQ(photoOutput_->Capture(), SUCCESS);
249 sleep(WAIT_TIME_AFTER_CAPTURE);
250
251 EXPECT_EQ(photoFlag_, true);
252 photoOutput_->UnSetPhotoAvailableCallback();
253 photoFlag_ = false;
254
255 EXPECT_EQ(session_->Stop(), SUCCESS);
256 }
257
258 /*
259 * Feature: Framework
260 * Function: Test the photoAsset available callback
261 * SubFunction: NA
262 * FunctionPoints: NA
263 * EnvConditions: NA
264 * CaseDescription: Test the photoAsset available callback, when capture is ok.
265 */
266 HWTEST_F(CameraPhotoModuleTest, camera_photo_moduletest_002, TestSize.Level0)
267 {
268 EXPECT_EQ(CreatePreviewOutput(previewProfile_[0], previewOutput_), SUCCESS);
269 EXPECT_EQ(CreatePhotoOutputWithoutSurface(photoProfile_[0], photoOutput_), SUCCESS);
270 EXPECT_EQ(session_->BeginConfig(), SUCCESS);
271 EXPECT_EQ(session_->AddInput((sptr<CaptureInput>&)input_), SUCCESS);
272 EXPECT_EQ(session_->AddOutput((sptr<CaptureOutput>&)previewOutput_), SUCCESS);
273 EXPECT_EQ(session_->AddOutput((sptr<CaptureOutput>&)photoOutput_), SUCCESS);
274
275 std::shared_ptr<TestCaptureCallback> callback = std::make_shared<TestCaptureCallback>();
276 photoOutput_->SetPhotoAssetAvailableCallback(callback);
277 callbackFlag_ |= CAPTURE_PHOTO_ASSET;
278 photoOutput_->SetCallbackFlag(callbackFlag_);
279
280 EXPECT_EQ(session_->CommitConfig(), SUCCESS);
281 EXPECT_EQ(session_->Start(), SUCCESS);
282 sleep(WAIT_TIME_AFTER_START);
283
284 EXPECT_EQ(photoOutput_->Capture(), SUCCESS);
285 sleep(WAIT_TIME_AFTER_CAPTURE);
286
287 EXPECT_EQ(photoAssetFlag_, true);
288 photoOutput_->UnSetPhotoAssetAvailableCallback();
289 photoAssetFlag_ = false;
290
291 EXPECT_EQ(session_->Stop(), SUCCESS);
292 }
293
294 /*
295 * Feature: Framework
296 * Function: Test thumbnail callback
297 * SubFunction: NA
298 * FunctionPoints: NA
299 * EnvConditions: NA
300 * CaseDescription: Test thumbnail callback
301 */
302 HWTEST_F(CameraPhotoModuleTest, camera_photo_moduletest_003, TestSize.Level0)
303 {
304 EXPECT_EQ(CreateYuvPhotoOutput(), SUCCESS);
305 EXPECT_EQ(CreateYuvPreviewOutput(), SUCCESS);
306 EXPECT_EQ(photoOutput_->IsQuickThumbnailSupported(), SESSION_NOT_RUNNING);
307
308 EXPECT_EQ(session_->BeginConfig(), SUCCESS);
309 EXPECT_EQ(session_->AddInput((sptr<CaptureInput> &)input_), SUCCESS);
310 EXPECT_EQ(session_->AddOutput((sptr<CaptureOutput> &)previewOutput_), SUCCESS);
311 EXPECT_EQ(session_->AddOutput((sptr<CaptureOutput> &)photoOutput_), SUCCESS);
312
313 CHECK_RETURN_ELOG(photoOutput_->IsQuickThumbnailSupported() != SUCCESS, "device not support!");
314 EXPECT_EQ(photoOutput_->SetThumbnail(true), SUCCESS);
315 std::shared_ptr<TestCaptureCallback> callback = std::make_shared<TestCaptureCallback>();
316 photoOutput_->SetThumbnailCallback(callback);
317 photoOutput_->SetPhotoAssetAvailableCallback(callback);
318 callbackFlag_ |= CAPTURE_PHOTO_ASSET;
319 photoOutput_->SetCallbackFlag(callbackFlag_);
320
321 EXPECT_EQ(session_->CommitConfig(), SUCCESS);
322 EXPECT_EQ(session_->Start(), SUCCESS);
323 sleep(WAIT_TIME_AFTER_START);
324
325 EXPECT_EQ(photoOutput_->Capture(), SUCCESS);
326 sleep(WAIT_TIME_AFTER_CAPTURE);
327
328 EXPECT_EQ(photoAssetFlag_, true);
329 photoOutput_->UnSetPhotoAssetAvailableCallback();
330 photoAssetFlag_ = false;
331 EXPECT_EQ(thumbnailFlag_, true);
332 photoOutput_->UnSetThumbnailAvailableCallback();
333 thumbnailFlag_ = false;
334 }
335 } // namespace CameraStandard
336 } // namespace OHOS