1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define MLOG_TAG "MultiStagesPhotoCaptureUnitTest"
17
18 #include "medialibrary_multistages_capture_test.h"
19
20 #include <chrono>
21 #include <thread>
22
23 #include "gmock/gmock.h"
24 #include "image_source.h"
25 #include "media_exif.h"
26 #include "media_column.h"
27 #include "media_file_utils.h"
28 #include "media_log.h"
29 #include "medialibrary_command.h"
30 #include "medialibrary_common_utils.h"
31 #include "medialibrary_data_manager.h"
32 #include "medialibrary_db_const_sqls.h"
33 #include "medialibrary_errno.h"
34 #include "medialibrary_photo_operations.h"
35 #include "medialibrary_rdbstore.h"
36 #include "medialibrary_unistore_manager.h"
37 #include "medialibrary_unittest_utils.h"
38 #include "result_set_utils.h"
39 #include "values_bucket.h"
40 #include "picture_adapter.h"
41 #define private public
42 #define protected public
43 #include "exif_utils.h"
44 #include "file_utils.h"
45 #include "mock_deferred_photo_proc_adapter.h"
46 #include "multistages_capture_deferred_photo_proc_session_callback.h"
47 #include "multistages_capture_dfx_first_visit.h"
48 #include "multistages_capture_dfx_result.h"
49 #include "multistages_capture_dfx_total_time.h"
50 #include "multistages_capture_dfx_request_policy.h"
51 #include "multistages_capture_dfx_trigger_ratio.h"
52 #include "multistages_capture_request_task_manager.h"
53 #include "multistages_photo_capture_manager.h"
54 #undef private
55 #undef protected
56
57 using namespace std;
58 using namespace OHOS;
59 using namespace OHOS::NativeRdb;
60 using namespace testing::ext;
61 using namespace testing;
62
63 namespace OHOS {
64 namespace Media {
65 static shared_ptr<MediaLibraryRdbStore> g_rdbStore;
66 static constexpr int32_t SLEEP_FIVE_SECONDS = 5;
67
68 namespace {
CleanTestTables()69 void CleanTestTables()
70 {
71 vector<string> dropTableList = {
72 PhotoColumn::PHOTOS_TABLE,
73 AudioColumn::AUDIOS_TABLE,
74 MEDIALIBRARY_TABLE,
75 ASSET_UNIQUE_NUMBER_TABLE
76 };
77 for (auto &dropTable : dropTableList) {
78 string dropSql = "DROP TABLE " + dropTable + ";";
79 int32_t ret = g_rdbStore->ExecuteSql(dropSql);
80 if (ret != NativeRdb::E_OK) {
81 MEDIA_ERR_LOG("Drop %{public}s table failed", dropTable.c_str());
82 return;
83 }
84 MEDIA_DEBUG_LOG("Drop %{public}s table success", dropTable.c_str());
85 }
86 }
87
88 struct UniqueMemberValuesBucket {
89 string assetMediaType;
90 int32_t startNumber;
91 };
92
PrepareUniqueNumberTable()93 void PrepareUniqueNumberTable()
94 {
95 if (g_rdbStore == nullptr) {
96 MEDIA_ERR_LOG("can not get g_rdbStore");
97 return;
98 }
99
100 string queryRowSql = "SELECT COUNT(*) as count FROM " + ASSET_UNIQUE_NUMBER_TABLE;
101 auto resultSet = g_rdbStore->QuerySql(queryRowSql);
102 if (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK) {
103 MEDIA_ERR_LOG("Can not get AssetUniqueNumberTable count");
104 return;
105 }
106 if (GetInt32Val("count", resultSet) != 0) {
107 MEDIA_DEBUG_LOG("AssetUniqueNumberTable is already inited");
108 return;
109 }
110
111 UniqueMemberValuesBucket imageBucket = { IMAGE_ASSET_TYPE, 1 };
112 UniqueMemberValuesBucket videoBucket = { VIDEO_ASSET_TYPE, 1 };
113 UniqueMemberValuesBucket audioBucket = { AUDIO_ASSET_TYPE, 1 };
114
115 vector<UniqueMemberValuesBucket> uniqueNumberValueBuckets = {
116 imageBucket, videoBucket, audioBucket
117 };
118
119 for (const auto& uniqueNumberValueBucket : uniqueNumberValueBuckets) {
120 ValuesBucket valuesBucket;
121 valuesBucket.PutString(ASSET_MEDIA_TYPE, uniqueNumberValueBucket.assetMediaType);
122 valuesBucket.PutInt(UNIQUE_NUMBER, uniqueNumberValueBucket.startNumber);
123 int64_t outRowId = -1;
124 int32_t insertResult = g_rdbStore->Insert(outRowId, ASSET_UNIQUE_NUMBER_TABLE, valuesBucket);
125 if (insertResult != NativeRdb::E_OK || outRowId <= 0) {
126 MEDIA_ERR_LOG("Prepare PrepareUniqueNumberTable failed");
127 }
128 }
129 }
130
SetTables()131 void SetTables()
132 {
133 vector<string> createTableSqlList = {
134 PhotoColumn::CREATE_PHOTO_TABLE,
135 AudioColumn::CREATE_AUDIO_TABLE,
136 CREATE_MEDIA_TABLE,
137 CREATE_ASSET_UNIQUE_NUMBER_TABLE
138 };
139 for (auto &createTableSql : createTableSqlList) {
140 int32_t ret = g_rdbStore->ExecuteSql(createTableSql);
141 if (ret != NativeRdb::E_OK) {
142 MEDIA_ERR_LOG("Execute sql %{private}s failed", createTableSql.c_str());
143 return;
144 }
145 MEDIA_DEBUG_LOG("Execute sql %{private}s success", createTableSql.c_str());
146 }
147 PrepareUniqueNumberTable();
148 }
149
ClearAndRestart()150 void ClearAndRestart()
151 {
152 if (!MediaLibraryUnitTestUtils::IsValid()) {
153 MediaLibraryUnitTestUtils::Init();
154 }
155
156 system("rm -rf /storage/cloud/files/*");
157 system("rm -rf /storage/cloud/files/.thumbs");
158 system("rm -rf /storage/cloud/files/.editData");
159 for (const auto &dir : TEST_ROOT_DIRS) {
160 string ROOT_PATH = "/storage/cloud/100/files/";
161 bool ret = MediaFileUtils::CreateDirectory(ROOT_PATH + dir + "/");
162 CHECK_AND_PRINT_LOG(ret, "make %{public}s dir failed, ret=%{public}d", dir.c_str(), ret);
163 }
164 CleanTestTables();
165 SetTables();
166 }
167
CreatePhotoApi10(int mediaType,const string & displayName)168 inline int32_t CreatePhotoApi10(int mediaType, const string &displayName)
169 {
170 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::CREATE,
171 MediaLibraryApi::API_10);
172 ValuesBucket values;
173 values.PutString(MediaColumn::MEDIA_NAME, displayName);
174 values.PutInt(MediaColumn::MEDIA_TYPE, mediaType);
175 cmd.SetValueBucket(values);
176 return MediaLibraryPhotoOperations::Create(cmd);
177 }
178
GetFilePath(int fileId)179 string GetFilePath(int fileId)
180 {
181 if (fileId < 0) {
182 MEDIA_ERR_LOG("this file id %{private}d is invalid", fileId);
183 return "";
184 }
185
186 vector<string> columns = { PhotoColumn::MEDIA_FILE_PATH };
187 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY,
188 MediaLibraryApi::API_10);
189 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
190 if (g_rdbStore == nullptr) {
191 MEDIA_ERR_LOG("can not get rdbstore");
192 return "";
193 }
194 auto resultSet = g_rdbStore->Query(cmd, columns);
195 if (resultSet == nullptr || resultSet->GoToFirstRow() != NativeRdb::E_OK) {
196 MEDIA_ERR_LOG("Can not get file Path");
197 return "";
198 }
199 string path = GetStringVal(PhotoColumn::MEDIA_FILE_PATH, resultSet);
200 return path;
201 }
202
MakePhotoUnpending(int fileId)203 int32_t MakePhotoUnpending(int fileId)
204 {
205 if (fileId < 0) {
206 MEDIA_ERR_LOG("this file id %{private}d is invalid", fileId);
207 return E_INVALID_FILEID;
208 }
209
210 string path = GetFilePath(fileId);
211 if (path.empty()) {
212 MEDIA_ERR_LOG("Get path failed");
213 return E_INVALID_VALUES;
214 }
215 int32_t errCode = MediaFileUtils::CreateAsset(path);
216 if (errCode != E_OK) {
217 MEDIA_ERR_LOG("Can not create asset");
218 return errCode;
219 }
220
221 if (g_rdbStore == nullptr) {
222 MEDIA_ERR_LOG("can not get rdbstore");
223 return E_HAS_DB_ERROR;
224 }
225 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE);
226 ValuesBucket values;
227 values.PutLong(PhotoColumn::MEDIA_TIME_PENDING, 0);
228 cmd.SetValueBucket(values);
229 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
230 int32_t changedRows = -1;
231 errCode = g_rdbStore->Update(cmd, changedRows);
232 if (errCode != E_OK || changedRows <= 0) {
233 MEDIA_ERR_LOG("Update pending failed, errCode = %{public}d, changeRows = %{public}d",
234 errCode, changedRows);
235 return errCode;
236 }
237
238 return E_OK;
239 }
240
SetDefaultPhotoApi10(int mediaType,const string & displayName)241 int32_t SetDefaultPhotoApi10(int mediaType, const string &displayName)
242 {
243 int fileId = CreatePhotoApi10(mediaType, displayName);
244 if (fileId < 0) {
245 MEDIA_ERR_LOG("create photo failed, res=%{public}d", fileId);
246 return fileId;
247 }
248 int32_t errCode = MakePhotoUnpending(fileId);
249 if (errCode != E_OK) {
250 return errCode;
251 }
252 return fileId;
253 }
254
255 const string PHOTO_ID_FOR_TEST = "202312071614";
256
PrepareForFirstVisit()257 int32_t PrepareForFirstVisit()
258 {
259 auto fileId = SetDefaultPhotoApi10(MediaType::MEDIA_TYPE_IMAGE, "MultiStagesCaptureTest001.jpg");
260 EXPECT_GT(fileId, 0);
261
262 // update multi-stages capture db info
263 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
264 ValuesBucket values;
265 values.Put(PhotoColumn::PHOTO_QUALITY, static_cast<int32_t>(MultiStagesPhotoQuality::LOW));
266 values.Put(PhotoColumn::PHOTO_ID, PHOTO_ID_FOR_TEST);
267 values.Put(PhotoColumn::PHOTO_DEFERRED_PROC_TYPE, 1);
268 cmd.SetValueBucket(values);
269 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
270 EXPECT_GT(MediaLibraryPhotoOperations::Update(cmd), E_OK);
271
272 return fileId;
273 }
274 } // namespace
275
SetUpTestCase(void)276 void MediaLibraryMultiStagesPhotoCaptureTest::SetUpTestCase(void)
277 {
278 MediaLibraryUnitTestUtils::Init();
279 g_rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
280 if (g_rdbStore == nullptr) {
281 MEDIA_ERR_LOG("Start MediaLibraryPhotoOperationsTest failed, can not get rdbstore");
282 exit(1);
283 }
284 SetTables();
285 }
286
TearDownTestCase(void)287 void MediaLibraryMultiStagesPhotoCaptureTest::TearDownTestCase(void)
288 {
289 if (!MediaLibraryUnitTestUtils::IsValid()) {
290 MediaLibraryUnitTestUtils::Init();
291 }
292
293 system("rm -rf /storage/cloud/files/*");
294 ClearAndRestart();
295 g_rdbStore = nullptr;
296 MediaLibraryDataManager::GetInstance()->ClearMediaLibraryMgr();
297 this_thread::sleep_for(chrono::seconds(SLEEP_FIVE_SECONDS));
298 MEDIA_INFO_LOG("Clean is finish");
299 }
300
301 // SetUp:Execute before each test case
SetUp()302 void MediaLibraryMultiStagesPhotoCaptureTest::SetUp()
303 {
304 if (g_rdbStore == nullptr) {
305 MEDIA_ERR_LOG("Start MediaLibraryPhotoOperationsTest failed, can not get rdbstore");
306 exit(1);
307 }
308 ClearAndRestart();
309 }
310
TearDown(void)311 void MediaLibraryMultiStagesPhotoCaptureTest::TearDown(void) {}
312
313 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_result_001, TestSize.Level1)
314 {
315 MEDIA_INFO_LOG("dfx_result_001 Start");
316 EXPECT_NE(g_rdbStore, nullptr);
317 MultiStagesCaptureDfxResult::Report("123456", 0, static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
318 MEDIA_INFO_LOG("dfx_result_001 End");
319 }
320
321 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_result_invalid_param_002, TestSize.Level1)
322 {
323 MEDIA_INFO_LOG("dfx_result_invalid_param_002 Start");
324 EXPECT_NE(g_rdbStore, nullptr);
325 MultiStagesCaptureDfxResult::Report("", 0, static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
326 MEDIA_INFO_LOG("dfx_result_invalid_param_002 End");
327 }
328
329 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_total_time_001, TestSize.Level1)
330 {
331 MEDIA_INFO_LOG("dfx_total_time_001 Start");
332 string photoId = "1234566";
333 MultiStagesCaptureDfxTotalTime::GetInstance().AddStartTime(photoId);
334 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), false);
335
336 // sleep for 1234 milliseconds
337 this_thread::sleep_for(chrono::milliseconds(1234));
338 MultiStagesCaptureDfxTotalTime::GetInstance().Report(photoId,
339 static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
340 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), true);
341
342 MEDIA_INFO_LOG("dfx_total_time_001 End");
343 }
344
345 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_total_time_two_start_002, TestSize.Level1)
346 {
347 MEDIA_INFO_LOG("dfx_total_time_two_start_002 Start");
348 string photoId = "1234566";
349
350 // test that photo_id is not add start time
351 MultiStagesCaptureDfxTotalTime::GetInstance().Report(photoId,
352 static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
353 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), true);
354
355 string photoId2 = "12345666";
356 MultiStagesCaptureDfxTotalTime::GetInstance().AddStartTime(photoId2);
357 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), false);
358
359 // sleep for 1234 milliseconds
360 this_thread::sleep_for(chrono::milliseconds(1234));
361 MultiStagesCaptureDfxTotalTime::GetInstance().Report(photoId,
362 static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
363 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), false);
364
365 MultiStagesCaptureDfxTotalTime::GetInstance().Report(photoId2,
366 static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
367 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), true);
368
369 MEDIA_INFO_LOG("dfx_total_time_two_start_002 End");
370 }
371
372 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_total_time_remove_start_time_003, TestSize.Level1)
373 {
374 MEDIA_INFO_LOG("dfx_total_time_remove_start_time_003 Start");
375
376 string photoId = "1234566";
377 MultiStagesCaptureDfxTotalTime::GetInstance().RemoveStartTime(photoId);
378 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), true);
379
380 MultiStagesCaptureDfxTotalTime::GetInstance().AddStartTime(photoId);
381 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), false);
382 sleep(1);
383 MultiStagesCaptureDfxTotalTime::GetInstance().RemoveStartTime(photoId);
384 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), true);
385
386 MEDIA_INFO_LOG("dfx_total_time_remove_start_time_003 End");
387 }
388
389 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_total_time_invalid_param_004, TestSize.Level1)
390 {
391 MEDIA_INFO_LOG("dfx_total_time_invalid_param_004 Start");
392 string photoId = "";
393 MultiStagesCaptureDfxTotalTime::GetInstance().AddStartTime(photoId);
394 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), false);
395
396 // sleep for 1234 milliseconds
397 this_thread::sleep_for(chrono::milliseconds(1234));
398 MultiStagesCaptureDfxTotalTime::GetInstance().Report(photoId,
399 static_cast<int32_t>(MultiStagesCaptureMediaType::IMAGE));
400 EXPECT_EQ(MultiStagesCaptureDfxTotalTime::GetInstance().startTimes_.empty(), true);
401
402 MEDIA_INFO_LOG("dfx_total_time_invalid_param_004 End");
403 }
404
405 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_request_policy_get_count_001, TestSize.Level1)
406 {
407 MEDIA_INFO_LOG("dfx_request_policy_get_count_001 Start");
408 RequestCount requestCount { 0, 0, 0 };
409 MultiStagesCaptureDfxRequestPolicy::GetInstance().GetCount(RequestPolicy::HIGH_QUALITY_MODE, requestCount);
410 EXPECT_EQ(requestCount.highQualityCount, 1);
411
412 MultiStagesCaptureDfxRequestPolicy::GetInstance().GetCount(RequestPolicy::BALANCE_MODE, requestCount);
413 EXPECT_EQ(requestCount.highQualityCount, 1);
414 EXPECT_EQ(requestCount.balanceQualityCount, 1);
415
416 MultiStagesCaptureDfxRequestPolicy::GetInstance().GetCount(RequestPolicy::FAST_MODE, requestCount);
417 EXPECT_EQ(requestCount.highQualityCount, 1);
418 EXPECT_EQ(requestCount.balanceQualityCount, 1);
419 EXPECT_EQ(requestCount.emergencyQualityCount, 1);
420
421 MultiStagesCaptureDfxRequestPolicy::GetInstance().GetCount(RequestPolicy::BALANCE_MODE, requestCount);
422 EXPECT_EQ(requestCount.highQualityCount, 1);
423 EXPECT_EQ(requestCount.balanceQualityCount, 2);
424 EXPECT_EQ(requestCount.emergencyQualityCount, 1);
425
426 MultiStagesCaptureDfxRequestPolicy::GetInstance().GetCount(static_cast<RequestPolicy>(3), requestCount);
427 EXPECT_EQ(requestCount.highQualityCount, 1);
428 EXPECT_EQ(requestCount.balanceQualityCount, 2);
429 EXPECT_EQ(requestCount.emergencyQualityCount, 1);
430
431 MEDIA_INFO_LOG("dfx_request_policy_get_count_001 End");
432 }
433
434 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_request_policy_set_policy_002, TestSize.Level1)
435 {
436 MEDIA_INFO_LOG("dfx_request_policy_set_policy_002 Start");
437
438 MultiStagesCaptureDfxRequestPolicy &requestPolicyInstance = MultiStagesCaptureDfxRequestPolicy::GetInstance();
439
440 string callingPackageName = "com.examples.photos";
441 requestPolicyInstance.SetPolicy(callingPackageName, RequestPolicy::HIGH_QUALITY_MODE);
442 // It will definitely be reported for the first time
443 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 0);
444
445 requestPolicyInstance.SetPolicy(callingPackageName, RequestPolicy::HIGH_QUALITY_MODE);
446 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 1);
447 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).highQualityCount, 1);
448
449 requestPolicyInstance.SetPolicy(callingPackageName, RequestPolicy::HIGH_QUALITY_MODE);
450 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 1);
451 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).highQualityCount, 2);
452
453 requestPolicyInstance.SetPolicy(callingPackageName, RequestPolicy::BALANCE_MODE);
454 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 1);
455 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).highQualityCount, 2);
456 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).balanceQualityCount, 1);
457
458 requestPolicyInstance.SetPolicy(callingPackageName, RequestPolicy::FAST_MODE);
459 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 1);
460 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).highQualityCount, 2);
461 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).balanceQualityCount, 1);
462 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName).emergencyQualityCount, 1);
463
464 // add another caller request
465 string callingPackageName2 = "com.examples.camera";
466 requestPolicyInstance.SetPolicy(callingPackageName2, RequestPolicy::HIGH_QUALITY_MODE);
467 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 2);
468 EXPECT_EQ(requestPolicyInstance.requestCountMap_.ReadVal(callingPackageName2).highQualityCount, 1);
469
470 // Simulate scenarios exceeding 24 hours
471 requestPolicyInstance.lastReportTime_ -= (24 * 60 * 60 * 1000L + 1);
472 requestPolicyInstance.SetPolicy(callingPackageName2, RequestPolicy::FAST_MODE);
473 EXPECT_EQ(requestPolicyInstance.requestCountMap_.Size(), 0);
474
475 requestPolicyInstance.requestCountMap_.Clear();
476 MEDIA_INFO_LOG("dfx_request_policy_set_policy_002 End");
477 }
478
479 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_first_visit_001, TestSize.Level1)
480 {
481 MEDIA_INFO_LOG("dfx_first_visit_001 Start");
482 auto fileId = PrepareForFirstVisit();
483 EXPECT_GT(fileId, 0);
484
485 // sleep for 1234 milliseconds
486 this_thread::sleep_for(chrono::milliseconds(1234));
487
488 MultiStagesCaptureDfxFirstVisit &instance = MultiStagesCaptureDfxFirstVisit::GetInstance();
489 instance.Report(PHOTO_ID_FOR_TEST);
490
491 // report again, it will not report to hiview
492 instance.Report(PHOTO_ID_FOR_TEST);
493
494 MEDIA_INFO_LOG("dfx_first_visit_001 End");
495 }
496
497 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_first_visit_invalid_param_002, TestSize.Level1)
498 {
499 MEDIA_INFO_LOG("dfx_first_visit_invalid_param_002 Start");
500 auto fileId = PrepareForFirstVisit();
501 EXPECT_GT(fileId, 0);
502
503 // sleep for 1234 milliseconds
504 this_thread::sleep_for(chrono::milliseconds(1234));
505
506 MultiStagesCaptureDfxFirstVisit &instance = MultiStagesCaptureDfxFirstVisit::GetInstance();
507 // photo id is empty
508 instance.Report("");
509
510 // photo id is not exist
511 instance.Report("1");
512
513 // report success
514 instance.Report(PHOTO_ID_FOR_TEST);
515
516 MEDIA_INFO_LOG("dfx_first_visit_invalid_param_002 End");
517 }
518
519 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, dfx_trigger_ratio_001, TestSize.Level1)
520 {
521 MEDIA_INFO_LOG("dfx_trigger_ratio_001 Start");
522 MultiStagesCaptureDfxTriggerRatio &instance = MultiStagesCaptureDfxTriggerRatio::GetInstance();
523 instance.SetTrigger(MultiStagesCaptureTriggerType::AUTO);
524 // report for first time
525 EXPECT_EQ(instance.autoCount_, 0);
526
527 instance.SetTrigger(MultiStagesCaptureTriggerType::AUTO);
528 EXPECT_EQ(instance.autoCount_, 1);
529 instance.SetTrigger(MultiStagesCaptureTriggerType::AUTO);
530 EXPECT_EQ(instance.autoCount_, 2);
531 instance.SetTrigger(MultiStagesCaptureTriggerType::THIRD_PART);
532 EXPECT_EQ(instance.autoCount_, 2);
533 EXPECT_EQ(instance.thirdPartCount_, 1);
534
535 // Simulate scenarios exceeding 24 hours
536 instance.lastReportTime_ -= (24 * 60 * 60 * 1000L + 1);
537 instance.SetTrigger(MultiStagesCaptureTriggerType::THIRD_PART);
538 EXPECT_EQ(instance.autoCount_, 0);
539 EXPECT_EQ(instance.thirdPartCount_, 0);
540
541 MEDIA_INFO_LOG("dfx_trigger_ratio_001 End");
542 }
543
544 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, manager_photo_id_add_and_rmv_001, TestSize.Level1)
545 {
546 MEDIA_INFO_LOG("manager_photo_id_add_and_rmv_001 Start");
547 string photoId = "202312251533001";
548 int32_t fileId = 1;
549 MultiStagesCaptureRequestTaskManager::AddPhotoInProgress(fileId, photoId, false);
550 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::fileId2PhotoId_.at(fileId), photoId);
551 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.at(photoId)->fileId, fileId);
552 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.at(photoId)->state, PhotoState::NORMAL);
553
554 string photoId2 = "202312251533002";
555 int32_t fileId2 = 2;
556 MultiStagesCaptureRequestTaskManager::AddPhotoInProgress(fileId2, photoId2, true);
557 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::fileId2PhotoId_.at(fileId2), photoId2);
558 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.at(photoId2)->fileId, fileId2);
559 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.at(photoId2)->state, PhotoState::TRASHED);
560
561 MultiStagesCaptureRequestTaskManager::RemovePhotoInProgress(photoId, false);
562 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::fileId2PhotoId_.count(fileId), 0);
563 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.count(photoId), 0);
564
565 MultiStagesCaptureRequestTaskManager::RemovePhotoInProgress(photoId2, false);
566 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::fileId2PhotoId_.count(fileId2), 0);
567 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.count(photoId2), 0);
568
569 // remove photo id not in progress
570 string invalidPhotoId = "202312251533003";
571 MultiStagesCaptureRequestTaskManager::RemovePhotoInProgress(invalidPhotoId, false);
572 MultiStagesCaptureRequestTaskManager::RemovePhotoInProgress(invalidPhotoId, true);
573 MEDIA_INFO_LOG("manager_photo_id_add_and_rmv_001 End");
574 }
575
576 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, exif_utils_location_value_to_string_001, TestSize.Level1)
577 {
578 MEDIA_INFO_LOG("exif_utils_location_value_to_string_001 Start");
579 double latitude = 31.2592678069444;
580 EXPECT_EQ(ExifUtils::LocationValueToString(latitude), "31, 15, 33.364105");
581
582 double longitude = 121.617393493611;
583 EXPECT_EQ(ExifUtils::LocationValueToString(longitude), "121, 37, 2.616577");
584 MEDIA_INFO_LOG("exif_utils_location_value_to_string_001 End");
585 }
586
587 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, exif_utils_location_value_to_string_002, TestSize.Level1)
588 {
589 MEDIA_INFO_LOG("exif_utils_location_value_to_string_002 Start");
590 double latitude = -31.2592678069444;
591 EXPECT_EQ(ExifUtils::LocationValueToString(latitude), "31, 15, 33.364105");
592
593 double longitude = -121.617393493611;
594 EXPECT_EQ(ExifUtils::LocationValueToString(longitude), "121, 37, 2.616577");
595 MEDIA_INFO_LOG("exif_utils_location_value_to_string_002 End");
596 }
597
598 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, session_callback_on_error_001, TestSize.Level1)
599 {
600 MEDIA_INFO_LOG("session_callback_on_error_001 Start");
601 auto fileId = PrepareForFirstVisit();
602 EXPECT_GT(fileId, 0);
603
604 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
605 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
606 callback->OnError(PHOTO_ID_FOR_TEST, CameraStandard::ERROR_IMAGE_PROC_FAILED);
607 delete callback;
608
609 vector<string> columns = { PhotoColumn::PHOTO_QUALITY };
610 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY, MediaLibraryApi::API_10);
611 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
612 ASSERT_NE(g_rdbStore, nullptr);
613
614 auto resultSet = g_rdbStore->Query(cmd, columns);
615 ASSERT_NE(resultSet, nullptr);
616 ASSERT_EQ(resultSet->GoToFirstRow(), NativeRdb::E_OK);
617
618 int32_t photoQuality = GetInt32Val(PhotoColumn::PHOTO_QUALITY, resultSet);
619 EXPECT_EQ(photoQuality, static_cast<int32_t>(MultiStagesPhotoQuality::FULL));
620
621 MEDIA_INFO_LOG("session_callback_on_error_001 End");
622 }
623
624 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, session_callback_on_error_002, TestSize.Level1)
625 {
626 MEDIA_INFO_LOG("session_callback_on_error_002 Start");
627 auto fileId = PrepareForFirstVisit();
628 EXPECT_GT(fileId, 0);
629
630 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
631 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
632 callback->OnError(PHOTO_ID_FOR_TEST, CameraStandard::ERROR_IMAGE_PROC_ABNORMAL);
633
634 vector<string> columns = { PhotoColumn::PHOTO_QUALITY };
635 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY, MediaLibraryApi::API_10);
636 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
637 ASSERT_NE(g_rdbStore, nullptr);
638
639 auto resultSet = g_rdbStore->Query(cmd, columns);
640 ASSERT_NE(resultSet, nullptr);
641 ASSERT_EQ(resultSet->GoToFirstRow(), NativeRdb::E_OK);
642
643 callback->NotifyIfTempFile(resultSet, true);
644 delete callback;
645 MEDIA_INFO_LOG("session_callback_on_error_002 End");
646 }
647
648 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, deferred_proc_adapter_null_session_001, TestSize.Level1)
649 {
650 MEDIA_INFO_LOG("deferred_proc_adapter_null_session_001 Start");
651 std::shared_ptr<DeferredPhotoProcessingAdapter> deferredProcSession = make_shared<DeferredPhotoProcessingAdapter>();
652 EXPECT_NE(deferredProcSession, nullptr);
653 // test deferredProcSession_ is nullptr;
654 deferredProcSession->deferredPhotoProcSession_ = nullptr;
655
656 deferredProcSession->BeginSynchronize();
657 deferredProcSession->EndSynchronize();
658 deferredProcSession->RestoreImage(PHOTO_ID_FOR_TEST);
659 deferredProcSession->ProcessImage("com.test.demo", PHOTO_ID_FOR_TEST);
660 deferredProcSession->CancelProcessImage(PHOTO_ID_FOR_TEST);
661 MEDIA_INFO_LOG("deferred_proc_adapter_null_session_001 End");
662 }
663
664 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, normal_deferred_proc_adapter_session, TestSize.Level1)
665 {
666 MEDIA_INFO_LOG("normal_deferred_proc_adapter_session Start");
667 std::shared_ptr<DeferredPhotoProcessingAdapter> deferredProcSession = make_shared<DeferredPhotoProcessingAdapter>();
668 EXPECT_NE(deferredProcSession, nullptr);
669
670 deferredProcSession->BeginSynchronize();
671 deferredProcSession->EndSynchronize();
672 deferredProcSession->RestoreImage(PHOTO_ID_FOR_TEST);
673 deferredProcSession->ProcessImage("com.test.demo", PHOTO_ID_FOR_TEST);
674 deferredProcSession->CancelProcessImage(PHOTO_ID_FOR_TEST);
675 MEDIA_INFO_LOG("normal_deferred_proc_adapter_session End");
676 }
677
678 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, file_utils_save_file_001, TestSize.Level1)
679 {
680 MEDIA_INFO_LOG("file_utils_save_file_001 Start");
681 const string testFileName = "/data/test/test.jpg";
682 char testOutput[] = "test.jpg";
683 FileUtils::SaveImage(testFileName, (void*)testOutput, sizeof(testOutput));
684 FileUtils::SaveMovingPhotoVideo(testFileName, false, false);
685
686 EXPECT_EQ(FileUtils::IsFileExist(testFileName), true);
687 EXPECT_EQ(FileUtils::IsFileExist(testFileName + ".tmp"), false);
688 EXPECT_EQ(FileUtils::DeleteFile(testFileName), 0);
689 MEDIA_INFO_LOG("file_utils_save_file_001 End");
690 }
691
692 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, file_utils_save_file_002, TestSize.Level1)
693 {
694 MEDIA_INFO_LOG("file_utils_save_file_002 Start");
695 const string testFileName = "/data/test/test.jpg";
696 std::shared_ptr<Media::Picture> picture;
697 bool isEdited = false;
698 bool isLowQualityPicture = false;
699 auto result = FileUtils::SavePicture(testFileName,
700 picture, isEdited, isLowQualityPicture);
701
702 EXPECT_EQ(result, -1);
703 }
704
705 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, manager_add_image_001, TestSize.Level1)
706 {
707 MEDIA_INFO_LOG("manager_add_image_001 Start");
708 auto fileId = PrepareForFirstVisit();
709 EXPECT_GT(fileId, 0);
710
711 MultiStagesPhotoCaptureManager &instance = MultiStagesPhotoCaptureManager::GetInstance();
712 instance.AddImage(fileId, PHOTO_ID_FOR_TEST, 0);
713 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::fileId2PhotoId_.count(fileId), 1);
714 EXPECT_EQ(MultiStagesCaptureRequestTaskManager::photoIdInProcess_.count(PHOTO_ID_FOR_TEST), 1);
715 MEDIA_INFO_LOG("manager_add_image_001 End");
716 }
717
718 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdatePhotoQuality_001, TestSize.Level1)
719 {
720 MEDIA_INFO_LOG("UpdatePhotoQuality_001 Start");
721 auto fileId = PrepareForFirstVisit();
722 EXPECT_GT(fileId, 0);
723
724 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
725 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
726 auto result = callback->UpdatePhotoQuality(PHOTO_ID_FOR_TEST);
727 EXPECT_EQ(result, E_OK);
728 delete callback;
729
730 vector<string> columns = { PhotoColumn::PHOTO_QUALITY, PhotoColumn::PHOTO_DIRTY, PhotoColumn::PHOTO_IS_TEMP };
731 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY, MediaLibraryApi::API_10);
732 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
733 ASSERT_NE(g_rdbStore, nullptr);
734
735 auto resultSet = g_rdbStore->Query(cmd, columns);
736 ASSERT_NE(resultSet, nullptr);
737 ASSERT_EQ(resultSet->GoToFirstRow(), NativeRdb::E_OK);
738
739 int32_t photoQuality = GetInt32Val(PhotoColumn::PHOTO_QUALITY, resultSet);
740 EXPECT_EQ(photoQuality, static_cast<int32_t>(MultiStagesPhotoQuality::FULL));
741 EXPECT_EQ(GetInt32Val(PhotoColumn::PHOTO_DIRTY, resultSet), 1);
742 EXPECT_EQ(GetInt32Val(PhotoColumn::PHOTO_IS_TEMP, resultSet), 0);
743
744 MEDIA_INFO_LOG("UpdatePhotoQuality_001 End");
745 }
746
747 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdateCEAvailable_test, TestSize.Level1)
748 {
749 MEDIA_INFO_LOG("UpdateCEAvailable_test Start");
750 auto fileId = PrepareForFirstVisit();
751 EXPECT_GT(fileId, 0);
752
753 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
754 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
755 vector<string> columns = { PhotoColumn::MEDIA_NAME, PhotoColumn::MEDIA_FILE_PATH, PhotoColumn::MEDIA_TYPE };
756 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY, MediaLibraryApi::API_10);
757 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
758
759 auto resultSet = g_rdbStore->Query(cmd, columns);
760 ASSERT_NE(resultSet, nullptr);
761
762 callback->NotifyIfTempFile(resultSet);
763 callback->UpdateCEAvailable(to_string(fileId), 1);
764 callback->UpdateCEAvailable(to_string(fileId), 2);
765 callback->OnError(PHOTO_ID_FOR_TEST, CameraStandard::ERROR_SESSION_SYNC_NEEDED);
766 callback->OnError(PHOTO_ID_FOR_TEST, CameraStandard::ERROR_IMAGE_PROC_INTERRUPTED);
767 callback->OnStateChanged(CameraStandard::SESSION_STATE_RUNNALBE);
768 delete callback;
769 MEDIA_INFO_LOG("UpdateCEAvailable_test End");
770 }
771
772 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, ProcessAndSaveHighQualityImage_test_001, TestSize.Level1)
773 {
774 MEDIA_INFO_LOG("ProcessAndSaveHighQualityImage_test_001 Start");
775 auto fileId = PrepareForFirstVisit();
776 EXPECT_GT(fileId, 0);
777
778 MultiStagesCaptureDeferredPhotoProcSessionCallback * callback =
779 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
780 sptr<SurfaceBuffer> surfaceBuffer = SurfaceBuffer::Create();
781 std::shared_ptr<CameraStandard::PictureIntf> picture = std::make_shared<CameraStandard::PictureAdapter>();
782 picture->Create(surfaceBuffer);
783
784 callback->OnProcessImageDone(PHOTO_ID_FOR_TEST, picture, true);
785 callback->OnProcessImageDone(to_string(fileId), picture, false);
786
787 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
788 ValuesBucket values;
789 values.Put(PhotoColumn::PHOTO_IS_TEMP, 1);
790 cmd.SetValueBucket(values);
791 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, fileId);
792 EXPECT_GT(MediaLibraryPhotoOperations::Update(cmd), E_OK);
793
794 callback->OnProcessImageDone(PHOTO_ID_FOR_TEST, picture, false);
795 callback->GetCommandByImageId(PHOTO_ID_FOR_TEST, cmd);
796 callback->GetCommandByImageId("2011/11/11", cmd);
797
798 delete callback;
799 MEDIA_INFO_LOG("ProcessAndSaveHighQualityImage_test_001 End");
800 }
801
802 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdateHighQualityPictureInfo_test, TestSize.Level1)
803 {
804 MEDIA_INFO_LOG("UpdateHighQualityPictureInfo_test Start");
805 auto fileId = PrepareForFirstVisit();
806 EXPECT_GT(fileId, 0);
807
808 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
809 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
810
811 callback->UpdateHighQualityPictureInfo(to_string(fileId), true);
812 callback->UpdateHighQualityPictureInfo(to_string(fileId), false);
813 delete callback;
814 MEDIA_INFO_LOG("UpdateHighQualityPictureInfo_test End");
815 }
816
817 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, OnDeliveryLowQualityImage_test, TestSize.Level1)
818 {
819 MEDIA_INFO_LOG("OnDeliveryLowQualityImage_test Start");
820 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
821 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
822
823 auto fileId = PrepareForFirstVisit();
824 EXPECT_GT(fileId, 0);
825
826 sptr<SurfaceBuffer> surfaceBuffer = SurfaceBuffer::Create();
827 std::shared_ptr<CameraStandard::PictureIntf> picture = std::make_shared<CameraStandard::PictureAdapter>();
828 callback->OnDeliveryLowQualityImage(to_string(fileId), picture);
829 picture->Create(surfaceBuffer);
830 callback->OnDeliveryLowQualityImage(to_string(fileId), picture);
831 callback->OnDeliveryLowQualityImage("fileId", picture);
832 delete callback;
833 MEDIA_INFO_LOG("OnDeliveryLowQualityImage_test End");
834 }
835
836 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, OnProcessImageDone_test_002, TestSize.Level1)
837 {
838 MEDIA_INFO_LOG("OnProcessImageDone_test_002 Start");
839 MultiStagesCaptureDeferredPhotoProcSessionCallback *callback =
840 new MultiStagesCaptureDeferredPhotoProcSessionCallback();
841
842 auto fileId = PrepareForFirstVisit();
843 EXPECT_GT(fileId, 0);
844
845 uint8_t addr = 1;
846 long bytes = 8;
847 MultiStagesCaptureRequestTaskManager::AddPhotoInProgress(1, to_string(fileId), true);
848 MultiStagesCaptureRequestTaskManager::AddPhotoInProgress(2, PHOTO_ID_FOR_TEST, false);
849 callback->OnProcessImageDone(to_string(fileId), &addr, bytes, true);
850 callback->OnProcessImageDone(PHOTO_ID_FOR_TEST, &addr, bytes, false);
851
852 ValuesBucket values;
853 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
854 values.Put(PhotoColumn::PHOTO_SUBTYPE, static_cast<int32_t>(PhotoSubType::MOVING_PHOTO));
855 cmd.SetValueBucket(values);
856 cmd.GetAbsRdbPredicates()->EqualTo(PhotoColumn::MEDIA_ID, fileId);
857 EXPECT_GT(MediaLibraryPhotoOperations::Update(cmd), E_OK);
858
859 callback->OnProcessImageDone(to_string(fileId), &addr, bytes, false);
860 delete callback;
861 MEDIA_INFO_LOG("OnProcessImageDone_test_002 End");
862 }
863
864 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdateDbInfoTest_normal_001, TestSize.Level1)
865 {
866 // test 1 PhotoColumn::PHOTO_SUBTYPE + PhotoSubType::MOVING_PHOTO
867 MEDIA_INFO_LOG("UpdateDbInfoTest_normal_001 Start");
868 auto fileId = PrepareForFirstVisit();
869 EXPECT_GT(fileId, 0);
870
871 ValuesBucket bucket;
872 MultiStagesPhotoCaptureManager &instance = MultiStagesPhotoCaptureManager::GetInstance();
873 MediaLibraryCommand cmd (OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE);
874 bucket.PutInt(PhotoColumn::PHOTO_SUBTYPE, static_cast<int32_t>(PhotoSubType::MOVING_PHOTO));
875 cmd.SetValueBucket(bucket);
876
877 auto ret = instance.UpdateDbInfo(cmd);
878 EXPECT_EQ(ret, 0);
879 MEDIA_INFO_LOG("UpdateDbInfoTest_normal_001 End");
880 }
881
882 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdateDbInfoTest_normal_002, TestSize.Level1)
883 {
884 MEDIA_INFO_LOG("UpdateDbInfoTest_normal_002 Start");
885 // test 2 PhotoColumn::PHOTO_SUBTYPE + !PhotoSubType::MOVING_PHOTO
886 auto fileId = PrepareForFirstVisit();
887 EXPECT_GT(fileId, 0);
888
889 ValuesBucket bucket;
890 MultiStagesPhotoCaptureManager &instance = MultiStagesPhotoCaptureManager::GetInstance();
891 MediaLibraryCommand cmd (OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE);
892 bucket.PutInt(PhotoColumn::PHOTO_SUBTYPE, static_cast<int32_t>(PhotoSubType::CAMERA));
893 cmd.SetValueBucket(bucket);
894
895 auto ret = instance.UpdateDbInfo(cmd);
896 EXPECT_EQ(ret, 0);
897 MEDIA_INFO_LOG("UpdateDbInfoTest_normal_002 End");
898 }
899
900 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdateDbInfoTest_empty_bucket_003, TestSize.Level1)
901 {
902 MEDIA_INFO_LOG("UpdateDbInfoTest_empty_bucket_003 Start");
903 // test3 empty bucket
904 auto fileId = PrepareForFirstVisit();
905 EXPECT_GT(fileId, 0);
906
907 ValuesBucket bucket;
908 MultiStagesPhotoCaptureManager &instance = MultiStagesPhotoCaptureManager::GetInstance();
909 MediaLibraryCommand cmd (OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE);
910 cmd.SetValueBucket(bucket);
911
912 auto ret = instance.UpdateDbInfo(cmd);
913 EXPECT_EQ(ret, 0);
914 MEDIA_INFO_LOG("UpdateDbInfoTest_empty_bucket_003 End");
915 }
916
917 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, UpdateDbInfoTest_nodata_004, TestSize.Level1)
918 {
919 MEDIA_INFO_LOG("UpdateDbInfoTest_nodata_004 Start");
920 // no data
921 ValuesBucket bucket;
922 MultiStagesPhotoCaptureManager &instance = MultiStagesPhotoCaptureManager::GetInstance();
923 MediaLibraryCommand cmd (OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE);
924 bucket.PutInt(PhotoColumn::PHOTO_SUBTYPE, static_cast<int32_t>(PhotoSubType::MOVING_PHOTO));
925 cmd.SetValueBucket(bucket);
926
927 auto ret = instance.UpdateDbInfo(cmd);
928 EXPECT_NE(ret, 0);
929 MEDIA_INFO_LOG("UpdateDbInfoTest_nodata_004 End");
930 }
931
932 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, WriteGpsExifInfo_test_001, TestSize.Level1)
933 {
934 MEDIA_INFO_LOG("WriteGpsExifInfo_test_001 start");
935
936 string path = "/valid/path";
937 double longitude = 0.0;
938 double latitude = 0.0;
939 auto ret = ExifUtils::WriteGpsExifInfo(path, longitude, latitude);
940 EXPECT_EQ(ret, -1);
941
942 MEDIA_INFO_LOG("WriteGpsExifInfo_test_001 end");
943 }
944
945 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, WriteGpsExifInfo_test_002, TestSize.Level1)
946 {
947 MEDIA_INFO_LOG("WriteGpsExifInfo_test_002 start");
948 string path = "/data/test/res/no_gps.jpg";
949 double longitude = 12.334455f;
950 double latitude = 35.667788f;
951 auto ret = ExifUtils::WriteGpsExifInfo(path, longitude, latitude);
952 EXPECT_EQ(ret, E_OK);
953
954 // check result
955 uint32_t errorCode = 0;
956 SourceOptions opts;
957 std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(path, opts, errorCode);
958 ASSERT_NE(imageSource, nullptr);
959
960 string propertyStr;
961 string refStr;
962 auto err = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LONGITUDE, propertyStr);
963 auto refErr = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LONGITUDE_REF, refStr);
964 EXPECT_EQ(err, 0);
965 EXPECT_EQ(refErr, 0);
966 EXPECT_NE(propertyStr, "");
967 EXPECT_EQ(refStr, "E");
968
969 err = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LATITUDE, propertyStr);
970 refErr = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LATITUDE_REF, refStr);
971 EXPECT_EQ(err, 0);
972 EXPECT_EQ(refErr, 0);
973 EXPECT_NE(propertyStr, "");
974 EXPECT_EQ(refStr, "N");
975
976 MEDIA_INFO_LOG("WriteGpsExifInfo_test_002 end");
977 }
978
979 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, WriteGpsExifInfo_test_003, TestSize.Level1)
980 {
981 MEDIA_INFO_LOG("WriteGpsExifInfo_test_003 start");
982 string path = "/data/test/res/no_gps.jpg";
983 double longitude = -120.334455f;
984 double latitude = -33.667788f;
985 auto ret = ExifUtils::WriteGpsExifInfo(path, longitude, latitude);
986 EXPECT_EQ(ret, E_OK);
987
988 // check result
989 uint32_t errorCode = 0;
990 SourceOptions opts;
991 std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(path, opts, errorCode);
992 ASSERT_NE(imageSource, nullptr);
993
994 string propertyStr;
995 string refStr;
996 auto err = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LONGITUDE, propertyStr);
997 auto refErr = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LONGITUDE_REF, refStr);
998 EXPECT_EQ(err, 0);
999 EXPECT_EQ(refErr, 0);
1000 EXPECT_NE(propertyStr, "");
1001 EXPECT_EQ(refStr, "W");
1002
1003 err = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LATITUDE, propertyStr);
1004 refErr = imageSource->GetImagePropertyString(0, PHOTO_DATA_IMAGE_GPS_LATITUDE_REF, refStr);
1005 EXPECT_EQ(err, 0);
1006 EXPECT_EQ(refErr, 0);
1007 EXPECT_NE(propertyStr, "");
1008 EXPECT_EQ(refStr, "S");
1009
1010 MEDIA_INFO_LOG("WriteGpsExifInfo_test_003 end");
1011 }
1012
1013 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, IsPhotoDeleted_test_001, TestSize.Level1)
1014 {
1015 MultiStagesPhotoCaptureManager& manager = MultiStagesPhotoCaptureManager::GetInstance();
1016 std::string photoId;
1017 auto ret = manager.IsPhotoDeleted(photoId);
1018 EXPECT_EQ(ret, false);
1019 }
1020
1021 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, IsPhotoDeleted_test_002, TestSize.Level1)
1022 {
1023 MultiStagesPhotoCaptureManager& manager = MultiStagesPhotoCaptureManager::GetInstance();
1024 std::string photoId = "abc";
1025 auto ret = manager.IsPhotoDeleted(photoId);
1026 EXPECT_EQ(ret, false);
1027 }
1028
1029 HWTEST_F(MediaLibraryMultiStagesPhotoCaptureTest, BeginSynchronize_test_001, TestSize.Level1)
1030 {
1031 DeferredPhotoProcessingAdapter adapter;
1032 EXPECT_NE(adapter.deferredPhotoProcSession_, nullptr);
1033 adapter.BeginSynchronize();
1034 }
1035 }
1036 }
