1 /*
2 * Copyright (C) 2021-2024 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 "DataManager"
17
18 #include "medialibrary_data_manager.h"
19
20 #include <cstdlib>
21 #include <shared_mutex>
22 #include <unordered_set>
23 #include <sstream>
24
25 #include "ability_scheduler_interface.h"
26 #include "abs_rdb_predicates.h"
27 #include "acl.h"
28 #include "background_cloud_file_processor.h"
29 #include "background_task_mgr_helper.h"
30 #include "cloud_sync_switch_observer.h"
31 #include "datashare_abs_result_set.h"
32 #ifdef DISTRIBUTED
33 #include "device_manager.h"
34 #include "device_manager_callback.h"
35 #endif
36 #include "dfx_manager.h"
37 #include "dfx_reporter.h"
38 #include "dfx_utils.h"
39 #include "efficiency_resource_info.h"
40 #include "hitrace_meter.h"
41 #include "ipc_skeleton.h"
42 #include "media_column.h"
43 #include "media_datashare_ext_ability.h"
44 #include "media_directory_type_column.h"
45 #include "media_file_utils.h"
46 #include "media_log.h"
47 #include "media_old_photos_column.h"
48 #include "media_scanner_manager.h"
49 #include "media_smart_album_column.h"
50 #include "media_smart_map_column.h"
51 #include "medialibrary_album_operations.h"
52 #include "medialibrary_analysis_album_operations.h"
53 #include "medialibrary_asset_operations.h"
54 #include "medialibrary_app_uri_permission_operations.h"
55 #include "medialibrary_app_uri_sensitive_operations.h"
56 #include "medialibrary_async_worker.h"
57 #include "medialibrary_audio_operations.h"
58 #include "medialibrary_bundle_manager.h"
59 #include "medialibrary_common_utils.h"
60 #ifdef DISTRIBUTED
61 #include "medialibrary_device.h"
62 #include "medialibrary_device_info.h"
63 #endif
64 #include "medialibrary_dir_operations.h"
65 #include "medialibrary_errno.h"
66 #include "medialibrary_file_operations.h"
67 #include "medialibrary_inotify.h"
68 #include "medialibrary_kvstore_manager.h"
69 #include "medialibrary_location_operations.h"
70 #include "medialibrary_object_utils.h"
71 #include "medialibrary_rdb_utils.h"
72 #include "medialibrary_rdbstore.h"
73 #include "medialibrary_restore.h"
74 #include "medialibrary_smartalbum_map_operations.h"
75 #include "medialibrary_smartalbum_operations.h"
76 #include "medialibrary_story_operations.h"
77 #include "medialibrary_sync_operation.h"
78 #include "medialibrary_tab_old_photos_operations.h"
79 #include "medialibrary_tracer.h"
80 #include "medialibrary_unistore_manager.h"
81 #include "medialibrary_uripermission_operations.h"
82 #include "medialibrary_urisensitive_operations.h"
83 #include "medialibrary_vision_operations.h"
84 #include "medialibrary_search_operations.h"
85 #include "mimetype_utils.h"
86 #include "multistages_capture_manager.h"
87 #include "enhancement_manager.h"
88 #include "permission_utils.h"
89 #include "photo_album_column.h"
90 #include "photo_map_operations.h"
91 #include "resource_type.h"
92 #include "rdb_store.h"
93 #include "rdb_utils.h"
94 #include "result_set_utils.h"
95 #include "system_ability_definition.h"
96 #include "timer.h"
97 #include "trash_async_worker.h"
98 #include "value_object.h"
99 #include "post_event_utils.h"
100 #include "medialibrary_formmap_operations.h"
101 #include "ithumbnail_helper.h"
102 #include "vision_face_tag_column.h"
103 #include "vision_photo_map_column.h"
104 #include "parameter.h"
105 #include "uuid.h"
106 #include "parameters.h"
107 #ifdef DEVICE_STANDBY_ENABLE
108 #include "medialibrary_standby_service_subscriber.h"
109 #endif
110
111 using namespace std;
112 using namespace OHOS::AppExecFwk;
113 using namespace OHOS::AbilityRuntime;
114 using namespace OHOS::NativeRdb;
115 using namespace OHOS::DistributedKv;
116 using namespace OHOS::DataShare;
117 using namespace OHOS::RdbDataShareAdapter;
118
119 namespace {
120 const OHOS::DistributedKv::AppId KVSTORE_APPID = {"com.ohos.medialibrary.medialibrarydata"};
121 const OHOS::DistributedKv::StoreId KVSTORE_STOREID = {"medialibrary_thumbnail"};
122 };
123
124 namespace OHOS {
125 namespace Media {
126 unique_ptr<MediaLibraryDataManager> MediaLibraryDataManager::instance_ = nullptr;
127 unordered_map<string, DirAsset> MediaLibraryDataManager::dirQuerySetMap_ = {};
128 mutex MediaLibraryDataManager::mutex_;
129 static const int32_t UUID_STR_LENGTH = 37;
130
131 #ifdef DEVICE_STANDBY_ENABLE
132 static const std::string SUBSCRIBER_NAME = "POWER_USAGE";
133 static const std::string MODULE_NAME = "com.ohos.medialibrary.medialibrarydata";
134 #endif
135 #ifdef DISTRIBUTED
136 static constexpr int MAX_QUERY_THUMBNAIL_KEY_COUNT = 20;
137 #endif
MediaLibraryDataManager(void)138 MediaLibraryDataManager::MediaLibraryDataManager(void)
139 {
140 }
141
~MediaLibraryDataManager(void)142 MediaLibraryDataManager::~MediaLibraryDataManager(void)
143 {
144 #ifdef DISTRIBUTED
145 if (kvStorePtr_ != nullptr) {
146 dataManager_.CloseKvStore(KVSTORE_APPID, kvStorePtr_);
147 kvStorePtr_ = nullptr;
148 }
149 #endif
150 }
151
GetInstance()152 MediaLibraryDataManager* MediaLibraryDataManager::GetInstance()
153 {
154 if (instance_ == nullptr) {
155 lock_guard<mutex> lock(mutex_);
156 if (instance_ == nullptr) {
157 instance_ = make_unique<MediaLibraryDataManager>();
158 }
159 }
160 return instance_.get();
161 }
162
MediaDataShareCreator(const unique_ptr<Runtime> & runtime)163 static DataShare::DataShareExtAbility *MediaDataShareCreator(const unique_ptr<Runtime> &runtime)
164 {
165 MEDIA_INFO_LOG("MediaLibraryCreator::%{public}s", __func__);
166 return MediaDataShareExtAbility::Create(runtime);
167 }
168
RegisterDataShareCreator()169 __attribute__((constructor)) void RegisterDataShareCreator()
170 {
171 MEDIA_INFO_LOG("MediaLibraryDataManager::%{public}s", __func__);
172 DataShare::DataShareExtAbility::SetCreator(MediaDataShareCreator);
173 MEDIA_INFO_LOG("MediaLibraryDataManager::%{public}s End", __func__);
174 }
175
MakeRootDirs(AsyncTaskData * data)176 static void MakeRootDirs(AsyncTaskData *data)
177 {
178 const unordered_set<string> DIR_CHECK_SET = { ROOT_MEDIA_DIR + BACKUP_DATA_DIR_VALUE,
179 ROOT_MEDIA_DIR + BACKUP_SINGLE_DATA_DIR_VALUE };
180 for (auto &dir : PRESET_ROOT_DIRS) {
181 Uri createAlbumUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_ALBUMOPRN + "/" + MEDIA_ALBUMOPRN_CREATEALBUM);
182 ValuesBucket valuesBucket;
183 valuesBucket.PutString(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR + dir);
184 MediaLibraryCommand cmd(createAlbumUri, valuesBucket);
185 auto ret = MediaLibraryAlbumOperations::CreateAlbumOperation(cmd);
186 if (ret == E_FILE_EXIST) {
187 MEDIA_INFO_LOG("Root dir: %{private}s is exist", dir.c_str());
188 } else if (ret <= 0) {
189 MEDIA_ERR_LOG("Failed to preset root dir: %{private}s", dir.c_str());
190 }
191 MediaFileUtils::CheckDirStatus(DIR_CHECK_SET, ROOT_MEDIA_DIR + dir);
192 }
193 if (data->dataDisplay.compare(E_POLICY) == 0 && !PermissionUtils::SetEPolicy()) {
194 MEDIA_ERR_LOG("Failed to SetEPolicy fail");
195 }
196 MediaFileUtils::MediaFileDeletionRecord();
197 // recover temp dir
198 MediaFileUtils::RecoverMediaTempDir();
199 }
200
ReCreateMediaDir()201 void MediaLibraryDataManager::ReCreateMediaDir()
202 {
203 MediaFileUtils::BackupPhotoDir();
204 // delete E policy dir
205 for (const string &dir : E_POLICY_DIRS) {
206 if (!MediaFileUtils::DeleteDir(dir)) {
207 MEDIA_ERR_LOG("Delete dir fail, dir: %{public}s", DfxUtils::GetSafePath(dir).c_str());
208 }
209 }
210 // create C policy dir
211 InitACLPermission();
212 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
213 if (asyncWorker == nullptr) {
214 MEDIA_ERR_LOG("Can not get asyncWorker");
215 return;
216 }
217 AsyncTaskData* taskData = new (std::nothrow) AsyncTaskData();
218 if (taskData == nullptr) {
219 MEDIA_ERR_LOG("Failed to new taskData");
220 return;
221 }
222 shared_ptr<MediaLibraryAsyncTask> makeRootDirTask = make_shared<MediaLibraryAsyncTask>(MakeRootDirs, taskData);
223 if (makeRootDirTask != nullptr) {
224 asyncWorker->AddTask(makeRootDirTask, true);
225 } else {
226 MEDIA_WARN_LOG("Can not init make root dir task");
227 }
228 }
229
ReconstructMediaLibraryPhotoMap()230 static int32_t ReconstructMediaLibraryPhotoMap()
231 {
232 if (system::GetParameter("persist.multimedia.medialibrary.albumFusion.status", "1") == "1") {
233 return E_OK;
234 }
235 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
236 if (rdbStore == nullptr) {
237 MEDIA_ERR_LOG("Failed to get rdbstore, try again!");
238 rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
239 if (rdbStore == nullptr) {
240 MEDIA_ERR_LOG("Fatal error! Failed to get rdbstore, new cloud data is not processed!!");
241 return E_DB_FAIL;
242 }
243 }
244 MediaLibraryRdbStore::ReconstructMediaLibraryStorageFormat(rdbStore);
245 return E_OK;
246 }
247
HandleOtherInitOperations()248 void MediaLibraryDataManager::HandleOtherInitOperations()
249 {
250 InitRefreshAlbum();
251 UriPermissionOperations::DeleteAllTemporaryAsync();
252 UriSensitiveOperations::DeleteAllSensitiveAsync();
253 }
254
ExcuteAsyncWork()255 static int32_t ExcuteAsyncWork()
256 {
257 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
258 if (asyncWorker == nullptr) {
259 MEDIA_ERR_LOG("Can not get asyncWorker");
260 return E_ERR;
261 }
262 AsyncTaskData* taskData = new (std::nothrow) AsyncTaskData();
263 if (taskData == nullptr) {
264 MEDIA_ERR_LOG("Failed to new taskData");
265 return E_ERR;
266 }
267 taskData->dataDisplay = E_POLICY;
268 shared_ptr<MediaLibraryAsyncTask> makeRootDirTask = make_shared<MediaLibraryAsyncTask>(MakeRootDirs, taskData);
269 if (makeRootDirTask != nullptr) {
270 asyncWorker->AddTask(makeRootDirTask, true);
271 } else {
272 MEDIA_WARN_LOG("Can not init make root dir task");
273 }
274 return E_OK;
275 }
276
InitMediaLibraryMgr(const shared_ptr<OHOS::AbilityRuntime::Context> & context,const shared_ptr<OHOS::AbilityRuntime::Context> & extensionContext,int32_t & sceneCode)277 __attribute__((no_sanitize("cfi"))) int32_t MediaLibraryDataManager::InitMediaLibraryMgr(
278 const shared_ptr<OHOS::AbilityRuntime::Context> &context,
279 const shared_ptr<OHOS::AbilityRuntime::Context> &extensionContext, int32_t &sceneCode)
280 {
281 lock_guard<shared_mutex> lock(mgrSharedMutex_);
282
283 if (refCnt_.load() > 0) {
284 MEDIA_DEBUG_LOG("already initialized");
285 refCnt_++;
286 return E_OK;
287 }
288
289 InitResourceInfo();
290 context_ = context;
291 int32_t errCode = InitMediaLibraryRdbStore();
292 if (errCode != E_OK) {
293 sceneCode = DfxType::START_RDB_STORE_FAIL;
294 return errCode;
295 }
296 if (!MediaLibraryKvStoreManager::GetInstance().InitMonthAndYearKvStore(KvStoreRoleType::OWNER)) {
297 MEDIA_ERR_LOG("failed at InitMonthAndYearKvStore");
298 }
299 #ifdef DISTRIBUTED
300 errCode = InitDeviceData();
301 CHECK_AND_RETURN_RET_LOG(errCode == E_OK, errCode, "failed at InitDeviceData");
302 #endif
303 MimeTypeUtils::InitMimeTypeMap();
304 errCode = MakeDirQuerySetMap(dirQuerySetMap_);
305 CHECK_AND_WARN_LOG(errCode == E_OK, "failed at MakeDirQuerySetMap");
306 InitACLPermission();
307 InitDatabaseACLPermission();
308 errCode = ExcuteAsyncWork();
309 CHECK_AND_RETURN_RET_LOG(errCode == E_OK, errCode, "failed at ExcuteAsyncWork");
310 errCode = InitialiseThumbnailService(extensionContext);
311 CHECK_AND_RETURN_RET_LOG(errCode == E_OK, errCode, "failed at InitialiseThumbnailService");
312 ReconstructMediaLibraryPhotoMap();
313 HandleOtherInitOperations();
314
315 auto shareHelper = MediaLibraryHelperContainer::GetInstance()->GetDataShareHelper();
316 cloudPhotoObserver_ = std::make_shared<CloudSyncObserver>();
317 cloudPhotoAlbumObserver_ = std::make_shared<CloudSyncObserver>();
318 shareHelper->RegisterObserverExt(Uri(PhotoColumn::PHOTO_CLOUD_URI_PREFIX), cloudPhotoObserver_, true);
319 shareHelper->RegisterObserverExt(Uri(PhotoAlbumColumns::ALBUM_CLOUD_URI_PREFIX), cloudPhotoAlbumObserver_, true);
320 HandleUpgradeRdbAsync();
321 CloudSyncSwitchManager cloudSyncSwitchManager;
322 cloudSyncSwitchManager.RegisterObserver();
323 SubscriberPowerConsumptionDetection();
324
325 refCnt_++;
326 return E_OK;
327 }
328
HandleUpgradeRdbAsync()329 void MediaLibraryDataManager::HandleUpgradeRdbAsync()
330 {
331 std::thread([&] {
332 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
333 if (rdbStore == nullptr) {
334 MEDIA_ERR_LOG("rdbStore is nullptr!");
335 return;
336 }
337 int32_t oldVersion = rdbStore->GetOldVersion();
338 if (oldVersion == -1 || oldVersion >= MEDIA_RDB_VERSION) {
339 MEDIA_INFO_LOG("No need to upgrade rdb, oldVersion: %{public}d", oldVersion);
340 return;
341 }
342 MEDIA_INFO_LOG("oldVersion:%{public}d", oldVersion);
343 // compare older version, update and set old version
344 if (oldVersion < VERSION_CREATE_BURSTKEY_INDEX) {
345 MediaLibraryRdbStore::CreateBurstIndex(rdbStore);
346 rdbStore->SetOldVersion(VERSION_CREATE_BURSTKEY_INDEX);
347 }
348
349 if (oldVersion < VERSION_UPDATE_BURST_DIRTY) {
350 MediaLibraryRdbStore::UpdateBurstDirty(rdbStore);
351 rdbStore->SetOldVersion(VERSION_UPDATE_BURST_DIRTY);
352 }
353
354 if (oldVersion < VERSION_UPGRADE_THUMBNAIL) {
355 MediaLibraryRdbStore::UpdateReadyOnThumbnailUpgrade(rdbStore);
356 rdbStore->SetOldVersion(VERSION_UPGRADE_THUMBNAIL);
357 }
358
359 if (oldVersion < VERSION_MOVE_AUDIOS) {
360 MediaLibraryAudioOperations::MoveToMusic();
361 MediaLibraryRdbStore::ClearAudios(rdbStore);
362 rdbStore->SetOldVersion(VERSION_MOVE_AUDIOS);
363 }
364
365 if (oldVersion < VERSION_ADD_DETAIL_TIME) {
366 MediaLibraryRdbStore::UpdateDateTakenToMillionSecond(rdbStore);
367 MediaLibraryRdbStore::UpdateDateTakenIndex(rdbStore);
368 ThumbnailService::GetInstance()->AstcChangeKeyFromDateAddedToDateTaken();
369 rdbStore->SetOldVersion(VERSION_ADD_DETAIL_TIME);
370 }
371
372 rdbStore->SetOldVersion(MEDIA_RDB_VERSION);
373 }).detach();
374 }
375
InitResourceInfo()376 void MediaLibraryDataManager::InitResourceInfo()
377 {
378 BackgroundTaskMgr::EfficiencyResourceInfo resourceInfo =
379 BackgroundTaskMgr::EfficiencyResourceInfo(BackgroundTaskMgr::ResourceType::CPU, true, 0, "apply", true, true);
380 BackgroundTaskMgr::BackgroundTaskMgrHelper::ApplyEfficiencyResources(resourceInfo);
381 }
382
383 #ifdef DISTRIBUTED
InitDeviceData()384 int32_t MediaLibraryDataManager::InitDeviceData()
385 {
386 if (rdbStore_ == nullptr) {
387 MEDIA_ERR_LOG("MediaLibraryDataManager InitDeviceData rdbStore is null");
388 return E_ERR;
389 }
390
391 MediaLibraryTracer tracer;
392 tracer.Start("InitDeviceRdbStoreTrace");
393 if (!MediaLibraryDevice::GetInstance()->InitDeviceRdbStore(rdbStore_)) {
394 MEDIA_ERR_LOG("MediaLibraryDataManager InitDeviceData failed!");
395 return E_ERR;
396 }
397 return E_OK;
398 }
399 #endif
400
ClearMediaLibraryMgr()401 __attribute__((no_sanitize("cfi"))) void MediaLibraryDataManager::ClearMediaLibraryMgr()
402 {
403 lock_guard<shared_mutex> lock(mgrSharedMutex_);
404
405 refCnt_--;
406 if (refCnt_.load() > 0) {
407 MEDIA_DEBUG_LOG("still other extension exist");
408 return;
409 }
410
411 BackgroundCloudFileProcessor::StopTimer();
412
413 auto shareHelper = MediaLibraryHelperContainer::GetInstance()->GetDataShareHelper();
414 if (shareHelper == nullptr) {
415 MEDIA_ERR_LOG("DataShareHelper is null");
416 return;
417 }
418 shareHelper->UnregisterObserverExt(Uri(PhotoColumn::PHOTO_CLOUD_URI_PREFIX), cloudPhotoObserver_);
419 shareHelper->UnregisterObserverExt(Uri(PhotoAlbumColumns::ALBUM_CLOUD_URI_PREFIX), cloudPhotoAlbumObserver_);
420 rdbStore_ = nullptr;
421 MediaLibraryKvStoreManager::GetInstance().CloseAllKvStore();
422 MEDIA_INFO_LOG("CloseKvStore success");
423
424 #ifdef DISTRIBUTED
425 if (kvStorePtr_ != nullptr) {
426 dataManager_.CloseKvStore(KVSTORE_APPID, kvStorePtr_);
427 kvStorePtr_ = nullptr;
428 }
429
430 if (MediaLibraryDevice::GetInstance()) {
431 MediaLibraryDevice::GetInstance()->Stop();
432 };
433 #endif
434
435 if (thumbnailService_ != nullptr) {
436 thumbnailService_->ReleaseService();
437 thumbnailService_ = nullptr;
438 }
439 auto watch = MediaLibraryInotify::GetInstance();
440 if (watch != nullptr) {
441 watch->DoStop();
442 }
443 MediaLibraryUnistoreManager::GetInstance().Stop();
444 extension_ = nullptr;
445 }
446
InitMediaLibraryRdbStore()447 int32_t MediaLibraryDataManager::InitMediaLibraryRdbStore()
448 {
449 if (rdbStore_) {
450 return E_OK;
451 }
452
453 int32_t ret = MediaLibraryUnistoreManager::GetInstance().Init(context_);
454 if (ret != E_OK) {
455 MEDIA_ERR_LOG("init MediaLibraryUnistoreManager failed");
456 return ret;
457 }
458 rdbStore_ = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
459 if (ret != E_OK) {
460 MEDIA_ERR_LOG("rdbStore is nullptr");
461 return E_ERR;
462 }
463
464 return E_OK;
465 }
466
InitRefreshAlbum()467 void MediaLibraryDataManager::InitRefreshAlbum()
468 {
469 bool isNeedRefresh = false;
470 int32_t ret = MediaLibraryRdbUtils::IsNeedRefreshByCheckTable(rdbStore_, isNeedRefresh);
471 if (ret != E_OK || isNeedRefresh) {
472 // Only set flag here, should not do any task in InitDataMgr
473 MediaLibraryRdbUtils::SetNeedRefreshAlbum(true);
474 }
475 }
476
GetOwner()477 shared_ptr<MediaDataShareExtAbility> MediaLibraryDataManager::GetOwner()
478 {
479 return extension_;
480 }
481
SetOwner(const shared_ptr<MediaDataShareExtAbility> & datashareExternsion)482 void MediaLibraryDataManager::SetOwner(const shared_ptr<MediaDataShareExtAbility> &datashareExternsion)
483 {
484 extension_ = datashareExternsion;
485 }
486
GetType(const Uri & uri)487 string MediaLibraryDataManager::GetType(const Uri &uri)
488 {
489 MEDIA_INFO_LOG("GetType uri: %{private}s", uri.ToString().c_str());
490 return "";
491 }
492
MakeDirQuerySetMap(unordered_map<string,DirAsset> & outDirQuerySetMap)493 int32_t MediaLibraryDataManager::MakeDirQuerySetMap(unordered_map<string, DirAsset> &outDirQuerySetMap)
494 {
495 int32_t count = -1;
496 vector<string> columns;
497 AbsRdbPredicates dirAbsPred(MEDIATYPE_DIRECTORY_TABLE);
498 if (rdbStore_ == nullptr) {
499 MEDIA_ERR_LOG("rdbStore_ is nullptr");
500 return E_ERR;
501 }
502 auto queryResultSet = rdbStore_->QueryByStep(dirAbsPred, columns);
503 if (queryResultSet == nullptr) {
504 MEDIA_ERR_LOG("queryResultSet is nullptr");
505 return E_ERR;
506 }
507 auto ret = queryResultSet->GetRowCount(count);
508 if (ret != NativeRdb::E_OK) {
509 MEDIA_ERR_LOG("rdb failed");
510 return E_ERR;
511 }
512 MEDIA_INFO_LOG("MakeDirQuerySetMap count = %{public}d", count);
513 if (count == 0) {
514 MEDIA_ERR_LOG("can not find any dirAsset");
515 return E_ERR;
516 }
517 DirAsset dirAsset;
518 string dirVal;
519 outDirQuerySetMap.clear();
520 while (queryResultSet->GoToNextRow() == NativeRdb::E_OK) {
521 dirVal = get<string>(
522 ResultSetUtils::GetValFromColumn(DIRECTORY_DB_DIRECTORY, queryResultSet, TYPE_STRING));
523 dirAsset.SetDirectory(dirVal);
524 dirAsset.SetDirType(get<int32_t>(
525 ResultSetUtils::GetValFromColumn(DIRECTORY_DB_DIRECTORY_TYPE, queryResultSet, TYPE_INT32)));
526 dirAsset.SetMediaTypes(get<string>(
527 ResultSetUtils::GetValFromColumn(DIRECTORY_DB_MEDIA_TYPE, queryResultSet, TYPE_STRING)));
528 dirAsset.SetExtensions(get<string>(
529 ResultSetUtils::GetValFromColumn(DIRECTORY_DB_EXTENSION, queryResultSet, TYPE_STRING)));
530 outDirQuerySetMap.insert(make_pair(dirVal, dirAsset));
531 }
532 return E_OK;
533 }
534
GetDirQuerySetMap()535 unordered_map<string, DirAsset> MediaLibraryDataManager::GetDirQuerySetMap()
536 {
537 return dirQuerySetMap_;
538 }
539
540 #ifdef MEDIALIBRARY_COMPATIBILITY
ChangeUriFromValuesBucket(ValuesBucket & values)541 static void ChangeUriFromValuesBucket(ValuesBucket &values)
542 {
543 if (!values.HasColumn(MEDIA_DATA_DB_URI)) {
544 return;
545 }
546
547 ValueObject value;
548 if (!values.GetObject(MEDIA_DATA_DB_URI, value)) {
549 return;
550 }
551 string oldUri;
552 if (value.GetString(oldUri) != NativeRdb::E_OK) {
553 return;
554 }
555 string newUri = MediaFileUtils::GetRealUriFromVirtualUri(oldUri);
556 values.Delete(MEDIA_DATA_DB_URI);
557 values.PutString(MEDIA_DATA_DB_URI, newUri);
558 }
559 #endif
560
SolveInsertCmd(MediaLibraryCommand & cmd)561 int32_t MediaLibraryDataManager::SolveInsertCmd(MediaLibraryCommand &cmd)
562 {
563 switch (cmd.GetOprnObject()) {
564 case OperationObject::FILESYSTEM_ASSET:
565 return MediaLibraryFileOperations::HandleFileOperation(cmd);
566
567 case OperationObject::FILESYSTEM_PHOTO:
568 case OperationObject::FILESYSTEM_AUDIO:
569 return MediaLibraryAssetOperations::HandleInsertOperation(cmd);
570
571 case OperationObject::FILESYSTEM_ALBUM:
572 return MediaLibraryAlbumOperations::CreateAlbumOperation(cmd);
573
574 case OperationObject::ANALYSIS_PHOTO_ALBUM:
575 case OperationObject::PHOTO_ALBUM:
576 return MediaLibraryAlbumOperations::HandlePhotoAlbumOperations(cmd);
577
578 case OperationObject::FILESYSTEM_DIR:
579 return MediaLibraryDirOperations::HandleDirOperation(cmd);
580
581 case OperationObject::SMART_ALBUM: {
582 string packageName = MediaLibraryBundleManager::GetInstance()->GetClientBundleName();
583 MEDIA_INFO_LOG("%{public}s call smart album insert!", packageName.c_str());
584 return MediaLibrarySmartAlbumOperations::HandleSmartAlbumOperation(cmd);
585 }
586 case OperationObject::SMART_ALBUM_MAP:
587 return MediaLibrarySmartAlbumMapOperations::HandleSmartAlbumMapOperation(cmd);
588
589 case OperationObject::THUMBNAIL:
590 return HandleThumbnailOperations(cmd);
591
592 case OperationObject::BUNDLE_PERMISSION:
593 return UriPermissionOperations::HandleUriPermOperations(cmd);
594 case OperationObject::APP_URI_PERMISSION_INNER: {
595 int32_t ret = UriSensitiveOperations::InsertOperation(cmd);
596 if (ret < 0) {
597 return ret;
598 }
599 return UriPermissionOperations::InsertOperation(cmd);
600 }
601 case OperationObject::MEDIA_APP_URI_PERMISSION: {
602 int32_t ret = MediaLibraryAppUriSensitiveOperations::HandleInsertOperation(cmd);
603 if (ret != MediaLibraryAppUriSensitiveOperations::SUCCEED) {
604 return ret;
605 }
606 return MediaLibraryAppUriPermissionOperations::HandleInsertOperation(cmd);
607 }
608 default:
609 break;
610 }
611 return SolveInsertCmdSub(cmd);
612 }
613
SolveInsertCmdSub(MediaLibraryCommand & cmd)614 int32_t MediaLibraryDataManager::SolveInsertCmdSub(MediaLibraryCommand &cmd)
615 {
616 if (MediaLibraryRestore::GetInstance().IsBackuping() && !MediaLibraryRestore::GetInstance().IsWaiting()) {
617 MEDIA_INFO_LOG("[SolveInsertCmdSub] rdb is backuping");
618 return E_FAIL;
619 }
620 switch (cmd.GetOprnObject()) {
621 case OperationObject::VISION_START ... OperationObject::VISION_END:
622 return MediaLibraryVisionOperations::InsertOperation(cmd);
623
624 case OperationObject::GEO_DICTIONARY:
625 case OperationObject::GEO_KNOWLEDGE:
626 case OperationObject::GEO_PHOTO:
627 return MediaLibraryLocationOperations::InsertOperation(cmd);
628
629 case OperationObject::SEARCH_TOTAL:
630 return MediaLibrarySearchOperations::InsertOperation(cmd);
631
632 case OperationObject::PAH_FORM_MAP:
633 return MediaLibraryFormMapOperations::HandleStoreFormIdOperation(cmd);
634
635 case OperationObject::STORY_ALBUM:
636 case OperationObject::STORY_COVER:
637 case OperationObject::STORY_PLAY:
638 case OperationObject::USER_PHOTOGRAPHY:
639 case OperationObject::ANALYSIS_ASSET_SD_MAP:
640 case OperationObject::ANALYSIS_ALBUM_ASSET_MAP:
641 return MediaLibraryStoryOperations::InsertOperation(cmd);
642 case OperationObject::ANALYSIS_PHOTO_MAP: {
643 return MediaLibrarySearchOperations::InsertOperation(cmd);
644 }
645 default:
646 MEDIA_ERR_LOG("MediaLibraryDataManager SolveInsertCmd: unsupported OperationObject: %{public}d",
647 cmd.GetOprnObject());
648 break;
649 }
650 return E_FAIL;
651 }
652
LogMovingPhoto(MediaLibraryCommand & cmd,const DataShareValuesBucket & dataShareValue)653 static int32_t LogMovingPhoto(MediaLibraryCommand &cmd, const DataShareValuesBucket &dataShareValue)
654 {
655 bool isValid = false;
656 bool adapted = bool(dataShareValue.Get("adapted", isValid));
657 if (!isValid) {
658 MEDIA_ERR_LOG("Invalid adapted value");
659 return E_ERR;
660 }
661 string packageName = MediaLibraryBundleManager::GetInstance()->GetClientBundleName();
662 if (packageName.empty()) {
663 MEDIA_WARN_LOG("Package name is empty, adapted: %{public}d", static_cast<int>(adapted));
664 }
665 DfxManager::GetInstance()->HandleAdaptationToMovingPhoto(packageName, adapted);
666 return E_OK;
667 }
668
LogMedialibraryAPI(MediaLibraryCommand & cmd,const DataShareValuesBucket & dataShareValue)669 static int32_t LogMedialibraryAPI(MediaLibraryCommand &cmd, const DataShareValuesBucket &dataShareValue)
670 {
671 string packageName = MediaLibraryBundleManager::GetInstance()->GetClientBundleName();
672 bool isValid = false;
673 string saveUri = string(dataShareValue.Get("saveUri", isValid));
674 CHECK_AND_RETURN_RET_LOG(isValid, E_FAIL, "Invalid saveUri value");
675 int32_t ret = DfxReporter::ReportMedialibraryAPI(packageName, saveUri);
676 if (ret != E_SUCCESS) {
677 MEDIA_ERR_LOG("Log medialibrary API failed");
678 }
679 return ret;
680 }
681
SolveOtherInsertCmd(MediaLibraryCommand & cmd,const DataShareValuesBucket & dataShareValue,bool & solved)682 static int32_t SolveOtherInsertCmd(MediaLibraryCommand &cmd, const DataShareValuesBucket &dataShareValue,
683 bool &solved)
684 {
685 solved = false;
686 switch (cmd.GetOprnObject()) {
687 case OperationObject::MISCELLANEOUS: {
688 if (cmd.GetOprnType() == OperationType::LOG_MOVING_PHOTO) {
689 solved = true;
690 return LogMovingPhoto(cmd, dataShareValue);
691 }
692 if (cmd.GetOprnType() == OperationType::LOG_MEDIALIBRARY_API) {
693 solved = true;
694 return LogMedialibraryAPI(cmd, dataShareValue);
695 }
696 return E_OK;
697 }
698 default:
699 return E_FAIL;
700 }
701 }
702
Insert(MediaLibraryCommand & cmd,const DataShareValuesBucket & dataShareValue)703 int32_t MediaLibraryDataManager::Insert(MediaLibraryCommand &cmd, const DataShareValuesBucket &dataShareValue)
704 {
705 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
706 if (refCnt_.load() <= 0) {
707 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
708 return E_FAIL;
709 }
710
711 ValuesBucket value = RdbUtils::ToValuesBucket(dataShareValue);
712 if (value.IsEmpty()) {
713 MEDIA_ERR_LOG("MediaLibraryDataManager Insert: Input parameter is invalid");
714 return E_INVALID_VALUES;
715 }
716 #ifdef MEDIALIBRARY_COMPATIBILITY
717 ChangeUriFromValuesBucket(value);
718 #endif
719 cmd.SetValueBucket(value);
720
721 OperationType oprnType = cmd.GetOprnType();
722 if (oprnType == OperationType::CREATE || oprnType == OperationType::SUBMIT_CACHE
723 || oprnType == OperationType::ADD_FILTERS) {
724 if (SetCmdBundleAndDevice(cmd) != ERR_OK) {
725 MEDIA_ERR_LOG("MediaLibraryDataManager SetCmdBundleAndDevice failed.");
726 }
727 }
728 // boardcast operation
729 if (oprnType == OperationType::SCAN) {
730 return MediaScannerManager::GetInstance()->ScanDir(ROOT_MEDIA_DIR, nullptr);
731 } else if (oprnType == OperationType::DELETE_TOOL) {
732 return MediaLibraryAssetOperations::DeleteToolOperation(cmd);
733 }
734
735 bool solved = false;
736 int32_t ret = SolveOtherInsertCmd(cmd, dataShareValue, solved);
737 if (solved) {
738 return ret;
739 }
740 return SolveInsertCmd(cmd);
741 }
742
InsertExt(MediaLibraryCommand & cmd,const DataShareValuesBucket & dataShareValue,string & result)743 int32_t MediaLibraryDataManager::InsertExt(MediaLibraryCommand &cmd, const DataShareValuesBucket &dataShareValue,
744 string &result)
745 {
746 int32_t ret = Insert(cmd, dataShareValue);
747 result = cmd.GetResult();
748 return ret;
749 }
750
HandleThumbnailOperations(MediaLibraryCommand & cmd)751 int32_t MediaLibraryDataManager::HandleThumbnailOperations(MediaLibraryCommand &cmd)
752 {
753 if (thumbnailService_ == nullptr) {
754 return E_THUMBNAIL_SERVICE_NULLPTR;
755 }
756 int32_t result = E_FAIL;
757 switch (cmd.GetOprnType()) {
758 case OperationType::GENERATE:
759 result = thumbnailService_->GenerateThumbnailBackground();
760 break;
761 case OperationType::AGING:
762 result = thumbnailService_->LcdAging();
763 break;
764 #ifdef DISTRIBUTED
765 case OperationType::DISTRIBUTE_AGING:
766 result = DistributeDeviceAging();
767 break;
768 #endif
769 default:
770 MEDIA_ERR_LOG("bad operation type %{public}u", cmd.GetOprnType());
771 }
772 return result;
773 }
774
BatchInsert(MediaLibraryCommand & cmd,const vector<DataShareValuesBucket> & values)775 int32_t MediaLibraryDataManager::BatchInsert(MediaLibraryCommand &cmd, const vector<DataShareValuesBucket> &values)
776 {
777 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
778 if (refCnt_.load() <= 0) {
779 MEDIA_ERR_LOG("MediaLibraryDataManager is not initialized");
780 return E_FAIL;
781 }
782
783 string uriString = cmd.GetUri().ToString();
784 if (uriString == UFM_PHOTO_ALBUM_ADD_ASSET || uriString == PAH_PHOTO_ALBUM_ADD_ASSET) {
785 return PhotoMapOperations::AddPhotoAssets(values);
786 } else if (cmd.GetOprnObject() == OperationObject::ANALYSIS_PHOTO_MAP) {
787 return PhotoMapOperations::AddAnaLysisPhotoAssets(values);
788 } else if (cmd.GetOprnObject() == OperationObject::APP_URI_PERMISSION_INNER) {
789 int32_t ret = UriSensitiveOperations::GrantUriSensitive(cmd, values);
790 if (ret < 0) {
791 return ret;
792 }
793 return UriPermissionOperations::GrantUriPermission(cmd, values);
794 } else if (cmd.GetOprnObject() == OperationObject::MEDIA_APP_URI_PERMISSION) {
795 int32_t ret = MediaLibraryAppUriSensitiveOperations::BatchInsert(cmd, values);
796 if (ret != MediaLibraryAppUriSensitiveOperations::SUCCEED) {
797 return ret;
798 }
799 return MediaLibraryAppUriPermissionOperations::BatchInsert(cmd, values);
800 }
801 if (uriString.find(MEDIALIBRARY_DATA_URI) == string::npos) {
802 MEDIA_ERR_LOG("MediaLibraryDataManager BatchInsert: Input parameter is invalid");
803 return E_INVALID_URI;
804 }
805 int32_t rowCount = 0;
806 for (auto it = values.begin(); it != values.end(); it++) {
807 if (Insert(cmd, *it) >= 0) {
808 rowCount++;
809 }
810 }
811
812 return rowCount;
813 }
814
Delete(MediaLibraryCommand & cmd,const DataSharePredicates & predicates)815 int32_t MediaLibraryDataManager::Delete(MediaLibraryCommand &cmd, const DataSharePredicates &predicates)
816 {
817 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
818 if (refCnt_.load() <= 0) {
819 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
820 return E_FAIL;
821 }
822
823 string uriString = cmd.GetUri().ToString();
824 if (MediaFileUtils::StartsWith(uriString, PhotoColumn::PHOTO_CACHE_URI_PREFIX)) {
825 return MediaLibraryAssetOperations::DeleteOperation(cmd);
826 }
827
828 if (uriString.find(MEDIALIBRARY_DATA_URI) == string::npos) {
829 MEDIA_ERR_LOG("Not Data ability Uri");
830 return E_INVALID_URI;
831 }
832 MediaLibraryTracer tracer;
833 tracer.Start("CheckWhereClause");
834 auto whereClause = predicates.GetWhereClause();
835 if (!MediaLibraryCommonUtils::CheckWhereClause(whereClause)) {
836 MEDIA_ERR_LOG("illegal query whereClause input %{private}s", whereClause.c_str());
837 return E_SQL_CHECK_FAIL;
838 }
839 tracer.Finish();
840
841 // MEDIALIBRARY_TABLE just for RdbPredicates
842 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates,
843 cmd.GetTableName());
844 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
845 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
846 return DeleteInRdbPredicates(cmd, rdbPredicate);
847 }
848
CheckIsDismissAsset(NativeRdb::RdbPredicates & rdbPredicate)849 bool CheckIsDismissAsset(NativeRdb::RdbPredicates &rdbPredicate)
850 {
851 auto whereClause = rdbPredicate.GetWhereClause();
852 if (whereClause.find(MAP_ALBUM) != string::npos && whereClause.find(MAP_ASSET) != string::npos) {
853 return true;
854 }
855 return false;
856 }
857
DeleteInRdbPredicates(MediaLibraryCommand & cmd,NativeRdb::RdbPredicates & rdbPredicate)858 int32_t MediaLibraryDataManager::DeleteInRdbPredicates(MediaLibraryCommand &cmd, NativeRdb::RdbPredicates &rdbPredicate)
859 {
860 switch (cmd.GetOprnObject()) {
861 case OperationObject::FILESYSTEM_ASSET:
862 case OperationObject::FILESYSTEM_DIR:
863 case OperationObject::FILESYSTEM_ALBUM: {
864 vector<string> columns = { MEDIA_DATA_DB_ID, MEDIA_DATA_DB_FILE_PATH, MEDIA_DATA_DB_PARENT_ID,
865 MEDIA_DATA_DB_MEDIA_TYPE, MEDIA_DATA_DB_IS_TRASH, MEDIA_DATA_DB_RELATIVE_PATH };
866 auto fileAsset = MediaLibraryObjectUtils::GetFileAssetByPredicates(*cmd.GetAbsRdbPredicates(), columns);
867 CHECK_AND_RETURN_RET_LOG(fileAsset != nullptr, E_INVALID_ARGUMENTS, "Get fileAsset failed.");
868 if (fileAsset->GetRelativePath() == "") {
869 return E_DELETE_DENIED;
870 }
871 return (fileAsset->GetMediaType() != MEDIA_TYPE_ALBUM) ?
872 MediaLibraryObjectUtils::DeleteFileObj(move(fileAsset)) :
873 MediaLibraryObjectUtils::DeleteDirObj(move(fileAsset));
874 }
875 case OperationObject::PHOTO_ALBUM:
876 return MediaLibraryAlbumOperations::DeletePhotoAlbum(rdbPredicate);
877 case OperationObject::PHOTO_MAP:
878 return PhotoMapOperations::RemovePhotoAssets(rdbPredicate);
879 case OperationObject::ANALYSIS_PHOTO_MAP: {
880 if (CheckIsDismissAsset(rdbPredicate)) {
881 return PhotoMapOperations::DismissAssets(rdbPredicate);
882 }
883 break;
884 }
885 case OperationObject::MEDIA_APP_URI_PERMISSION: {
886 return MediaLibraryAppUriPermissionOperations::DeleteOperation(rdbPredicate);
887 }
888 case OperationObject::FILESYSTEM_PHOTO:
889 case OperationObject::FILESYSTEM_AUDIO:
890 return MediaLibraryAssetOperations::DeleteOperation(cmd);
891 case OperationObject::PAH_FORM_MAP:
892 return MediaLibraryFormMapOperations::RemoveFormIdOperations(rdbPredicate);
893 default:
894 break;
895 }
896
897 return DeleteInRdbPredicatesAnalysis(cmd, rdbPredicate);
898 }
899
DeleteInRdbPredicatesAnalysis(MediaLibraryCommand & cmd,NativeRdb::RdbPredicates & rdbPredicate)900 int32_t MediaLibraryDataManager::DeleteInRdbPredicatesAnalysis(MediaLibraryCommand &cmd,
901 NativeRdb::RdbPredicates &rdbPredicate)
902 {
903 if (MediaLibraryRestore::GetInstance().IsBackuping() && !MediaLibraryRestore::GetInstance().IsWaiting()) {
904 MEDIA_INFO_LOG("[DeleteInRdbPredicatesAnalysis] rdb is backuping");
905 return E_FAIL;
906 }
907 switch (cmd.GetOprnObject()) {
908 case OperationObject::VISION_START ... OperationObject::VISION_END:
909 return MediaLibraryVisionOperations::DeleteOperation(cmd);
910
911 case OperationObject::GEO_DICTIONARY:
912 case OperationObject::GEO_KNOWLEDGE:
913 case OperationObject::GEO_PHOTO:
914 return MediaLibraryLocationOperations::DeleteOperation(cmd);
915
916 case OperationObject::STORY_ALBUM:
917 case OperationObject::STORY_COVER:
918 case OperationObject::STORY_PLAY:
919 case OperationObject::USER_PHOTOGRAPHY:
920 return MediaLibraryStoryOperations::DeleteOperation(cmd);
921
922 case OperationObject::SEARCH_TOTAL:
923 return MediaLibrarySearchOperations::DeleteOperation(cmd);
924 default:
925 break;
926 }
927
928 return E_FAIL;
929 }
930
Update(MediaLibraryCommand & cmd,const DataShareValuesBucket & dataShareValue,const DataSharePredicates & predicates)931 int32_t MediaLibraryDataManager::Update(MediaLibraryCommand &cmd, const DataShareValuesBucket &dataShareValue,
932 const DataSharePredicates &predicates)
933 {
934 MEDIA_DEBUG_LOG("MediaLibraryDataManager::Update");
935 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
936 if (refCnt_.load() <= 0) {
937 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
938 return E_FAIL;
939 }
940
941 ValuesBucket value = RdbUtils::ToValuesBucket(dataShareValue);
942 if (value.IsEmpty()) {
943 MEDIA_ERR_LOG("MediaLibraryDataManager Update:Input parameter is invalid ");
944 return E_INVALID_VALUES;
945 }
946
947 #ifdef MEDIALIBRARY_COMPATIBILITY
948 ChangeUriFromValuesBucket(value);
949 #endif
950
951 cmd.SetValueBucket(value);
952 cmd.SetDataSharePred(predicates);
953 // MEDIALIBRARY_TABLE just for RdbPredicates
954 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates,
955 cmd.GetTableName());
956 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
957 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
958 return UpdateInternal(cmd, value, predicates);
959 }
960
SplitUriString(const std::string & str,char delimiter)961 static std::vector<std::string> SplitUriString(const std::string& str, char delimiter)
962 {
963 std::vector<std::string> elements;
964 std::stringstream ss(str);
965 std::string item;
966 while (std::getline(ss, item, delimiter)) {
967 if (!item.empty()) {
968 elements.emplace_back(item);
969 }
970 }
971 return elements;
972 }
973
ExtractFileIdFromUri(const std::string & uri)974 static std::string ExtractFileIdFromUri(const std::string& uri)
975 {
976 auto uriParts = SplitUriString(uri, '/');
977 if (uriParts.size() >= MediaLibraryDataManager::URI_MIN_NUM) {
978 return uriParts[uriParts.size() - MediaLibraryDataManager::URI_MIN_NUM];
979 }
980 return "";
981 }
982
BuildWhereClause(const std::vector<std::string> & dismissAssetArray,int32_t albumId)983 static std::string BuildWhereClause(const std::vector<std::string>& dismissAssetArray, int32_t albumId)
984 {
985 std::string whereClause = MediaColumn::MEDIA_ID + " IN (";
986
987 for (size_t i = 0; i < dismissAssetArray.size(); ++i) {
988 std::string fileId = ExtractFileIdFromUri(dismissAssetArray[i]);
989 if (fileId.empty()) {
990 continue;
991 }
992
993 if (i > 0) {
994 whereClause += ",";
995 }
996
997 whereClause += "'" + fileId + "'";
998 }
999
1000 whereClause += ") AND EXISTS (SELECT 1 FROM " + ANALYSIS_ALBUM_TABLE +
1001 " WHERE " + ANALYSIS_ALBUM_TABLE + "." + PhotoAlbumColumns::ALBUM_ID +
1002 " = " + std::to_string(albumId) + " AND " +
1003 ANALYSIS_ALBUM_TABLE + ".tag_id = " + VISION_IMAGE_FACE_TABLE + ".tag_id)";
1004
1005 return whereClause;
1006 }
1007
HandleAnalysisFaceUpdate(MediaLibraryCommand & cmd,NativeRdb::ValuesBucket & value,const DataShare::DataSharePredicates & predicates)1008 static int HandleAnalysisFaceUpdate(MediaLibraryCommand& cmd, NativeRdb::ValuesBucket &value,
1009 const DataShare::DataSharePredicates &predicates)
1010 {
1011 string keyOperation = cmd.GetQuerySetParam(MEDIA_OPERN_KEYWORD);
1012 if (keyOperation.empty() || keyOperation != UPDATE_DISMISS_ASSET) {
1013 cmd.SetValueBucket(value);
1014 return MediaLibraryObjectUtils::ModifyInfoByIdInDb(cmd);
1015 }
1016
1017 const string &clause = predicates.GetWhereClause();
1018 std::vector<std::string> clauses = SplitUriString(clause, ',');
1019 if (clauses.empty()) {
1020 MEDIA_ERR_LOG("Clause is empty, cannot extract album ID.");
1021 return E_INVALID_FILEID;
1022 }
1023
1024 std::string albumStr = clauses[0];
1025 int32_t albumId {0};
1026 std::stringstream ss(albumStr);
1027 if (!(ss >> albumId)) {
1028 MEDIA_ERR_LOG("Unable to convert albumId string to integer.");
1029 return E_INVALID_FILEID;
1030 }
1031
1032 std::vector<std::string> uris;
1033 for (size_t i = 1; i < clauses.size(); ++i) {
1034 uris.push_back(clauses[i]);
1035 }
1036
1037 if (uris.empty()) {
1038 MEDIA_ERR_LOG("No URIs found after album ID.");
1039 return E_INVALID_FILEID;
1040 }
1041
1042 std::string predicate = BuildWhereClause(uris, albumId);
1043 cmd.SetValueBucket(value);
1044 cmd.GetAbsRdbPredicates()->SetWhereClause(predicate);
1045 return MediaLibraryObjectUtils::ModifyInfoByIdInDb(cmd);
1046 }
1047
HandleFilesystemOperations(MediaLibraryCommand & cmd)1048 static int32_t HandleFilesystemOperations(MediaLibraryCommand &cmd)
1049 {
1050 switch (cmd.GetOprnObject()) {
1051 case OperationObject::FILESYSTEM_ASSET: {
1052 auto ret = MediaLibraryFileOperations::ModifyFileOperation(cmd);
1053 if (ret == E_SAME_PATH) {
1054 return E_OK;
1055 } else {
1056 return ret;
1057 }
1058 }
1059 case OperationObject::FILESYSTEM_DIR:
1060 // supply a ModifyDirOperation here to replace
1061 // modify in the HandleDirOperations in Insert function, if need
1062 return E_OK;
1063
1064 case OperationObject::FILESYSTEM_ALBUM: {
1065 return MediaLibraryAlbumOperations::ModifyAlbumOperation(cmd);
1066 }
1067 default:
1068 return E_OK;
1069 }
1070 }
1071
UpdateInternal(MediaLibraryCommand & cmd,NativeRdb::ValuesBucket & value,const DataShare::DataSharePredicates & predicates)1072 int32_t MediaLibraryDataManager::UpdateInternal(MediaLibraryCommand &cmd, NativeRdb::ValuesBucket &value,
1073 const DataShare::DataSharePredicates &predicates)
1074 {
1075 int32_t result = HandleFilesystemOperations(cmd);
1076 if (result != E_OK) {
1077 return result;
1078 }
1079 switch (cmd.GetOprnObject()) {
1080 case OperationObject::PAH_PHOTO:
1081 case OperationObject::PAH_VIDEO:
1082 case OperationObject::FILESYSTEM_PHOTO:
1083 case OperationObject::FILESYSTEM_AUDIO:
1084 return MediaLibraryAssetOperations::UpdateOperation(cmd);
1085 case OperationObject::ANALYSIS_PHOTO_ALBUM: {
1086 if ((cmd.GetOprnType() >= OperationType::PORTRAIT_DISPLAY_LEVEL &&
1087 cmd.GetOprnType() <= OperationType::GROUP_COVER_URI)) {
1088 return MediaLibraryAlbumOperations::HandleAnalysisPhotoAlbum(cmd.GetOprnType(), value, predicates);
1089 }
1090 break;
1091 }
1092 case OperationObject::PHOTO_ALBUM:
1093 return MediaLibraryAlbumOperations::HandlePhotoAlbum(cmd.GetOprnType(), value, predicates);
1094 case OperationObject::GEO_DICTIONARY:
1095 case OperationObject::GEO_KNOWLEDGE:
1096 return MediaLibraryLocationOperations::UpdateOperation(cmd);
1097 case OperationObject::STORY_ALBUM:
1098 case OperationObject::STORY_COVER:
1099 case OperationObject::STORY_PLAY:
1100 case OperationObject::USER_PHOTOGRAPHY:
1101 return MediaLibraryStoryOperations::UpdateOperation(cmd);
1102 case OperationObject::PAH_MULTISTAGES_CAPTURE: {
1103 std::vector<std::string> columns;
1104 MultiStagesPhotoCaptureManager::GetInstance().HandleMultiStagesOperation(cmd, columns);
1105 return E_OK;
1106 }
1107 case OperationObject::PAH_BATCH_THUMBNAIL_OPERATE:
1108 return ProcessThumbnailBatchCmd(cmd, value, predicates);
1109 case OperationObject::PAH_CLOUD_ENHANCEMENT_OPERATE:
1110 return EnhancementManager::GetInstance().HandleEnhancementUpdateOperation(cmd);
1111 case OperationObject::VISION_IMAGE_FACE:
1112 return HandleAnalysisFaceUpdate(cmd, value, predicates);
1113 default:
1114 break;
1115 }
1116 // ModifyInfoByIdInDb can finish the default update of smartalbum and smartmap,
1117 // so no need to distinct them in switch-case deliberately
1118 cmd.SetValueBucket(value);
1119 return MediaLibraryObjectUtils::ModifyInfoByIdInDb(cmd);
1120 }
1121
InterruptBgworker()1122 void MediaLibraryDataManager::InterruptBgworker()
1123 {
1124 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1125 if (refCnt_.load() <= 0) {
1126 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1127 return;
1128 }
1129
1130 if (thumbnailService_ == nullptr) {
1131 return;
1132 }
1133 thumbnailService_->InterruptBgworker();
1134 shared_ptr<TrashAsyncTaskWorker> asyncWorker = TrashAsyncTaskWorker::GetInstance();
1135 if (asyncWorker == nullptr) {
1136 MEDIA_ERR_LOG("asyncWorker null");
1137 return;
1138 }
1139 asyncWorker->Interrupt();
1140 }
1141
GenerateThumbnailBackground()1142 int32_t MediaLibraryDataManager::GenerateThumbnailBackground()
1143 {
1144 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1145 if (refCnt_.load() <= 0) {
1146 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1147 return E_FAIL;
1148 }
1149
1150 if (thumbnailService_ == nullptr) {
1151 return E_THUMBNAIL_SERVICE_NULLPTR;
1152 }
1153 return thumbnailService_->GenerateThumbnailBackground();
1154 }
1155
UpgradeThumbnailBackground(bool isWifiConnected)1156 int32_t MediaLibraryDataManager::UpgradeThumbnailBackground(bool isWifiConnected)
1157 {
1158 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1159 if (refCnt_.load() <= 0) {
1160 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1161 return E_FAIL;
1162 }
1163
1164 if (thumbnailService_ == nullptr) {
1165 return E_THUMBNAIL_SERVICE_NULLPTR;
1166 }
1167 return thumbnailService_->UpgradeThumbnailBackground(isWifiConnected);
1168 }
1169
RestoreThumbnailDualFrame()1170 int32_t MediaLibraryDataManager::RestoreThumbnailDualFrame()
1171 {
1172 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1173 if (refCnt_.load() <= 0) {
1174 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1175 return E_FAIL;
1176 }
1177
1178 if (thumbnailService_ == nullptr) {
1179 return E_THUMBNAIL_SERVICE_NULLPTR;
1180 }
1181 return thumbnailService_->RestoreThumbnailDualFrame();
1182 }
1183
CacheAging()1184 static void CacheAging()
1185 {
1186 filesystem::path cacheDir(MEDIA_CACHE_DIR);
1187 if (!filesystem::exists(cacheDir)) {
1188 return;
1189 }
1190
1191 std::error_code errCode;
1192 time_t now = time(nullptr);
1193 constexpr int thresholdSeconds = 24 * 60 * 60; // 24 hours
1194 for (const auto& entry : filesystem::recursive_directory_iterator(cacheDir)) {
1195 string filePath = entry.path().string();
1196 if (!entry.is_regular_file()) {
1197 MEDIA_WARN_LOG("skip %{private}s, not regular file", filePath.c_str());
1198 continue;
1199 }
1200
1201 struct stat statInfo {};
1202 if (stat(filePath.c_str(), &statInfo) != 0) {
1203 MEDIA_WARN_LOG("skip %{private}s, stat errno: %{public}d", filePath.c_str(), errno);
1204 continue;
1205 }
1206 time_t timeModified = statInfo.st_mtime;
1207 double duration = difftime(now, timeModified); // diff in seconds
1208 if (duration < thresholdSeconds) {
1209 continue;
1210 }
1211
1212 if (!filesystem::remove(entry.path(), errCode)) {
1213 MEDIA_WARN_LOG("Failed to remove %{private}s, err: %{public}d", filePath.c_str(), errCode.value());
1214 }
1215 }
1216 }
1217
DoAging()1218 int32_t MediaLibraryDataManager::DoAging()
1219 {
1220 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1221 MEDIA_DEBUG_LOG("MediaLibraryDataManager::DoAging IN");
1222 if (refCnt_.load() <= 0) {
1223 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1224 return E_FAIL;
1225 }
1226
1227 CacheAging(); // aging file in .cache
1228
1229 shared_ptr<TrashAsyncTaskWorker> asyncWorker = TrashAsyncTaskWorker::GetInstance();
1230 if (asyncWorker == nullptr) {
1231 MEDIA_ERR_LOG("asyncWorker null");
1232 return E_FAIL;
1233 }
1234 asyncWorker->Init();
1235 return E_OK;
1236 }
1237
GenerateUuid()1238 static string GenerateUuid()
1239 {
1240 uuid_t uuid;
1241 uuid_generate(uuid);
1242 char str[UUID_STR_LENGTH] = {};
1243 uuid_unparse(uuid, str);
1244 return str;
1245 }
1246
generateRegexpMatchForNumber(const int32_t num)1247 static string generateRegexpMatchForNumber(const int32_t num)
1248 {
1249 string regexpMatchNumber = "[0-9]";
1250 string strRegexpMatch = "";
1251 for (int i = 0; i < num; i++) {
1252 strRegexpMatch += regexpMatchNumber;
1253 }
1254 return strRegexpMatch;
1255 }
1256
generateUpdateSql(const bool isCover,const string title,const int32_t ownerAlbumId)1257 static string generateUpdateSql(const bool isCover, const string title, const int32_t ownerAlbumId)
1258 {
1259 uint32_t index = title.find_first_of("BURST");
1260 string globMember = title.substr(0, index) + "BURST" + generateRegexpMatchForNumber(3);
1261 string globCover = globMember + "_COVER";
1262 string updateSql;
1263 if (isCover) {
1264 string burstkey = GenerateUuid();
1265 updateSql = "UPDATE " + PhotoColumn::PHOTOS_TABLE + " SET " + PhotoColumn::PHOTO_SUBTYPE + " = " +
1266 to_string(static_cast<int32_t>(PhotoSubType::BURST)) + ", " + PhotoColumn::PHOTO_BURST_KEY + " = '" +
1267 burstkey + "', " + PhotoColumn::PHOTO_BURST_COVER_LEVEL + " = CASE WHEN " + MediaColumn::MEDIA_TITLE +
1268 " NOT LIKE '%COVER%' THEN " + to_string(static_cast<int32_t>(BurstCoverLevelType::MEMBER)) + " ELSE " +
1269 to_string(static_cast<int32_t>(BurstCoverLevelType::COVER)) + " END WHERE " + MediaColumn::MEDIA_TYPE +
1270 " = " + to_string(static_cast<int32_t>(MEDIA_TYPE_IMAGE)) + " AND " + PhotoColumn::PHOTO_SUBTYPE + " != " +
1271 to_string(static_cast<int32_t>(PhotoSubType::MOVING_PHOTO)) + " AND " + PhotoColumn::PHOTO_OWNER_ALBUM_ID +
1272 " = " + to_string(ownerAlbumId) + " AND (LOWER(" + MediaColumn::MEDIA_TITLE + ") GLOB LOWER('" +
1273 globMember + "') OR LOWER(" + MediaColumn::MEDIA_TITLE + ") GLOB LOWER('" + globCover + "'));";
1274 } else {
1275 string subWhere = "FROM " + PhotoColumn::PHOTOS_TABLE + " AS p2 WHERE LOWER(p2." + MediaColumn::MEDIA_TITLE +
1276 ") GLOB LOWER('" + globCover + "') AND p2." + PhotoColumn::PHOTO_OWNER_ALBUM_ID + " = " +
1277 to_string(ownerAlbumId);
1278
1279 updateSql = "UPDATE " + PhotoColumn::PHOTOS_TABLE + " AS p1 SET " + PhotoColumn::PHOTO_BURST_KEY +
1280 " = (SELECT CASE WHEN p2." + PhotoColumn::PHOTO_BURST_KEY + " IS NOT NULL THEN p2." +
1281 PhotoColumn::PHOTO_BURST_KEY + " ELSE NULL END " + subWhere + " LIMIT 1 ), " +
1282 PhotoColumn::PHOTO_BURST_COVER_LEVEL + " = (SELECT CASE WHEN COUNT(1) > 0 THEN " +
1283 to_string(static_cast<int32_t>(BurstCoverLevelType::MEMBER)) + " ELSE " +
1284 to_string(static_cast<int32_t>(BurstCoverLevelType::COVER)) + " END " + subWhere + "), " +
1285 PhotoColumn::PHOTO_SUBTYPE + " = (SELECT CASE WHEN COUNT(1) > 0 THEN " +
1286 to_string(static_cast<int32_t>(PhotoSubType::BURST)) + " ELSE p1." + PhotoColumn::PHOTO_SUBTYPE + " END " +
1287 subWhere + ") WHERE p1." + MediaColumn::MEDIA_TITLE + " = '" + title + "' AND p1." +
1288 PhotoColumn::PHOTO_OWNER_ALBUM_ID + " = " + to_string(ownerAlbumId);
1289 }
1290 return updateSql;
1291 }
1292
UpdateBurstPhoto(const bool isCover,const shared_ptr<MediaLibraryRdbStore> rdbStore,shared_ptr<NativeRdb::ResultSet> resultSet)1293 static int32_t UpdateBurstPhoto(const bool isCover, const shared_ptr<MediaLibraryRdbStore> rdbStore,
1294 shared_ptr<NativeRdb::ResultSet> resultSet)
1295 {
1296 int32_t count;
1297 int32_t retCount = resultSet->GetRowCount(count);
1298 if (count == 0) {
1299 if (isCover) {
1300 MEDIA_INFO_LOG("No burst cover need to update");
1301 } else {
1302 MEDIA_INFO_LOG("No burst member need to update");
1303 }
1304 return E_SUCCESS;
1305 }
1306 if (retCount != E_SUCCESS || count < 0) {
1307 return E_ERR;
1308 }
1309
1310 int32_t ret = E_ERR;
1311 while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
1312 int columnIndex = 0;
1313 string title;
1314 if (resultSet->GetColumnIndex(MediaColumn::MEDIA_TITLE, columnIndex) == NativeRdb::E_OK) {
1315 resultSet->GetString(columnIndex, title);
1316 }
1317 int32_t ownerAlbumId = 0;
1318 if (resultSet->GetColumnIndex(PhotoColumn::PHOTO_OWNER_ALBUM_ID, columnIndex) == NativeRdb::E_OK) {
1319 resultSet->GetInt(columnIndex, ownerAlbumId);
1320 }
1321
1322 string updateSql = generateUpdateSql(isCover, title, ownerAlbumId);
1323 ret = rdbStore->ExecuteSql(updateSql);
1324 if (ret != NativeRdb::E_OK) {
1325 MEDIA_ERR_LOG("rdbStore->ExecuteSql failed, ret = %{public}d", ret);
1326 return E_HAS_DB_ERROR;
1327 }
1328 }
1329 return ret;
1330 }
1331
QueryBurst(const shared_ptr<MediaLibraryRdbStore> rdbStore,const string globNameRule1,const string globNameRule2)1332 static shared_ptr<NativeRdb::ResultSet> QueryBurst(const shared_ptr<MediaLibraryRdbStore> rdbStore,
1333 const string globNameRule1, const string globNameRule2)
1334 {
1335 string querySql = "SELECT " + MediaColumn::MEDIA_TITLE + ", " + PhotoColumn::PHOTO_OWNER_ALBUM_ID +
1336 " FROM " + PhotoColumn::PHOTOS_TABLE + " WHERE " + MediaColumn::MEDIA_TYPE + " = " +
1337 to_string(static_cast<int32_t>(MEDIA_TYPE_IMAGE)) + " AND " + PhotoColumn::PHOTO_SUBTYPE + " != " +
1338 to_string(static_cast<int32_t>(PhotoSubType::MOVING_PHOTO)) + " AND " + PhotoColumn::PHOTO_BURST_KEY +
1339 " IS NULL AND (LOWER(" + MediaColumn::MEDIA_TITLE + ") GLOB LOWER('" + globNameRule1 + "') OR LOWER(" +
1340 MediaColumn::MEDIA_TITLE + ") GLOB LOWER('" + globNameRule2 + "'))";
1341
1342 auto resultSet = rdbStore->QueryByStep(querySql);
1343 if (resultSet == nullptr) {
1344 MEDIA_ERR_LOG("failed to acquire result from visitor query.");
1345 }
1346 return resultSet;
1347 }
1348
UpdateBurstFromGallery()1349 int32_t MediaLibraryDataManager::UpdateBurstFromGallery()
1350 {
1351 MEDIA_INFO_LOG("Begin UpdateBurstFromGallery");
1352 MediaLibraryTracer tracer;
1353 tracer.Start("MediaLibraryDataManager::UpdateBurstFromGallery");
1354 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1355 if (refCnt_.load() <= 0) {
1356 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1357 return E_FAIL;
1358 }
1359 if (rdbStore_ == nullptr) {
1360 MEDIA_DEBUG_LOG("rdbStore_ is nullptr");
1361 return E_FAIL;
1362 }
1363
1364 string globNameRule = "IMG_" + generateRegexpMatchForNumber(8) + "_" + generateRegexpMatchForNumber(6) + "_";
1365
1366 // regexp match IMG_xxxxxxxx_xxxxxx_BURSTxxx, 'x' represents a number
1367 string globMemberStr1 = globNameRule + "BURST" + generateRegexpMatchForNumber(3);
1368 string globMemberStr2 = globNameRule + "[0-9]_BURST" + generateRegexpMatchForNumber(3);
1369 // regexp match IMG_xxxxxxxx_xxxxxx_BURSTxxx_COVER, 'x' represents a number
1370 string globCoverStr1 = globMemberStr1 + "_COVER";
1371 string globCoverStr2 = globMemberStr2 + "_COVER";
1372
1373 auto resultSet = QueryBurst(rdbStore_, globCoverStr1, globCoverStr2);
1374 int32_t ret = UpdateBurstPhoto(true, rdbStore_, resultSet);
1375 if (ret != E_SUCCESS) {
1376 MEDIA_ERR_LOG("failed to UpdateBurstPhotoByCovers.");
1377 return E_FAIL;
1378 }
1379
1380 resultSet = QueryBurst(rdbStore_, globMemberStr1, globMemberStr2);
1381 ret = UpdateBurstPhoto(false, rdbStore_, resultSet);
1382 if (ret != E_SUCCESS) {
1383 MEDIA_ERR_LOG("failed to UpdateBurstPhotoByMembers.");
1384 return E_FAIL;
1385 }
1386 MEDIA_INFO_LOG("End UpdateBurstFromGallery");
1387 return ret;
1388 }
1389
1390 #ifdef DISTRIBUTED
LcdDistributeAging()1391 int32_t MediaLibraryDataManager::LcdDistributeAging()
1392 {
1393 MEDIA_DEBUG_LOG("MediaLibraryDataManager::LcdDistributeAging IN");
1394 auto deviceInstance = MediaLibraryDevice::GetInstance();
1395 if ((thumbnailService_ == nullptr) || (deviceInstance == nullptr)) {
1396 return E_THUMBNAIL_SERVICE_NULLPTR;
1397 }
1398 int32_t result = E_SUCCESS;
1399 vector<string> deviceUdids;
1400 deviceInstance->QueryAllDeviceUdid(deviceUdids);
1401 for (string &udid : deviceUdids) {
1402 result = thumbnailService_->LcdDistributeAging(udid);
1403 if (result != E_SUCCESS) {
1404 MEDIA_ERR_LOG("LcdDistributeAging fail result is %{public}d", result);
1405 break;
1406 }
1407 }
1408 return result;
1409 }
1410
DistributeDeviceAging()1411 int32_t MediaLibraryDataManager::DistributeDeviceAging()
1412 {
1413 MEDIA_DEBUG_LOG("MediaLibraryDataManager::DistributeDeviceAging IN");
1414 auto deviceInstance = MediaLibraryDevice::GetInstance();
1415 if ((thumbnailService_ == nullptr) || (deviceInstance == nullptr)) {
1416 return E_FAIL;
1417 }
1418 int32_t result = E_FAIL;
1419 vector<MediaLibraryDeviceInfo> deviceDataBaseList;
1420 deviceInstance->QueryAgingDeviceInfos(deviceDataBaseList);
1421 MEDIA_DEBUG_LOG("MediaLibraryDevice InitDeviceRdbStore deviceDataBaseList size = %{public}d",
1422 (int) deviceDataBaseList.size());
1423 for (MediaLibraryDeviceInfo deviceInfo : deviceDataBaseList) {
1424 result = thumbnailService_->InvalidateDistributeThumbnail(deviceInfo.deviceUdid);
1425 if (result != E_SUCCESS) {
1426 MEDIA_ERR_LOG("invalidate fail %{public}d", result);
1427 continue;
1428 }
1429 }
1430 return result;
1431 }
1432 #endif
1433
GetThumbnail(const string & uri)1434 int MediaLibraryDataManager::GetThumbnail(const string &uri)
1435 {
1436 if (thumbnailService_ == nullptr) {
1437 return E_THUMBNAIL_SERVICE_NULLPTR;
1438 }
1439 if (!uri.empty() && MediaLibraryObjectUtils::CheckUriPending(uri)) {
1440 MEDIA_ERR_LOG("failed to get thumbnail, the file:%{private}s is pending", uri.c_str());
1441 return E_FAIL;
1442 }
1443 return thumbnailService_->GetThumbnailFd(uri);
1444 }
1445
CreateThumbnailAsync(const string & uri,const string & path)1446 void MediaLibraryDataManager::CreateThumbnailAsync(const string &uri, const string &path)
1447 {
1448 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1449 if (refCnt_.load() <= 0) {
1450 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1451 return;
1452 }
1453
1454 if (thumbnailService_ == nullptr) {
1455 return;
1456 }
1457 if (!uri.empty()) {
1458 if (MediaLibraryObjectUtils::CheckUriPending(uri)) {
1459 MEDIA_ERR_LOG("failed to get thumbnail, the file:%{private}s is pending", uri.c_str());
1460 return;
1461 }
1462 int32_t err = thumbnailService_->CreateThumbnailFileScaned(uri, path);
1463 if (err != E_SUCCESS) {
1464 MEDIA_ERR_LOG("ThumbnailService CreateThumbnailFileScaned failed : %{public}d", err);
1465 }
1466 }
1467 }
1468
Query(MediaLibraryCommand & cmd,const vector<string> & columns,const DataSharePredicates & predicates,int & errCode)1469 shared_ptr<ResultSetBridge> MediaLibraryDataManager::Query(MediaLibraryCommand &cmd,
1470 const vector<string> &columns, const DataSharePredicates &predicates, int &errCode)
1471 {
1472 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1473 if (refCnt_.load() <= 0) {
1474 errCode = E_FAIL;
1475 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1476 VariantMap map = {{KEY_ERR_FILE, __FILE__}, {KEY_ERR_LINE, __LINE__}, {KEY_ERR_CODE, errCode},
1477 {KEY_OPT_TYPE, OptType::QUERY}};
1478 PostEventUtils::GetInstance().PostErrorProcess(ErrType::DB_OPT_ERR, map);
1479 return nullptr;
1480 }
1481
1482 MediaLibraryTracer tracer;
1483 tracer.Start("MediaLibraryDataManager::Query");
1484 if (rdbStore_ == nullptr) {
1485 errCode = E_FAIL;
1486 MEDIA_ERR_LOG("Rdb Store is not initialized");
1487 VariantMap map = {{KEY_ERR_FILE, __FILE__}, {KEY_ERR_LINE, __LINE__}, {KEY_ERR_CODE, errCode},
1488 {KEY_OPT_TYPE, OptType::QUERY}};
1489 PostEventUtils::GetInstance().PostErrorProcess(ErrType::DB_OPT_ERR, map);
1490 return nullptr;
1491 }
1492
1493 auto absResultSet = QueryRdb(cmd, columns, predicates, errCode);
1494 if (absResultSet == nullptr) {
1495 errCode = (errCode != E_OK) ? errCode : E_FAIL;
1496 VariantMap map = {{KEY_ERR_FILE, __FILE__}, {KEY_ERR_LINE, __LINE__}, {KEY_ERR_CODE, errCode},
1497 {KEY_OPT_TYPE, OptType::QUERY}};
1498 PostEventUtils::GetInstance().PostErrorProcess(ErrType::DB_OPT_ERR, map);
1499 return nullptr;
1500 }
1501 return RdbUtils::ToResultSetBridge(absResultSet);
1502 }
1503
1504 #ifdef DISTRIBUTED
SyncPullThumbnailKeys(const Uri & uri)1505 int32_t MediaLibraryDataManager::SyncPullThumbnailKeys(const Uri &uri)
1506 {
1507 if (MediaLibraryDevice::GetInstance() == nullptr || !MediaLibraryDevice::GetInstance()->IsHasActiveDevice()) {
1508 return E_ERR;
1509 }
1510 if (kvStorePtr_ == nullptr) {
1511 return E_ERR;
1512 }
1513
1514 MediaLibraryCommand cmd(uri, OperationType::QUERY);
1515 cmd.GetAbsRdbPredicates()->BeginWrap()->EqualTo(MEDIA_DATA_DB_MEDIA_TYPE, to_string(MEDIA_TYPE_IMAGE))
1516 ->Or()->EqualTo(MEDIA_DATA_DB_MEDIA_TYPE, to_string(MEDIA_TYPE_VIDEO))->EndWrap()
1517 ->And()->EqualTo(MEDIA_DATA_DB_DATE_TRASHED, to_string(0))
1518 ->And()->NotEqualTo(MEDIA_DATA_DB_MEDIA_TYPE, to_string(MEDIA_TYPE_ALBUM))
1519 ->OrderByDesc(MEDIA_DATA_DB_DATE_ADDED);
1520 vector<string> columns = { MEDIA_DATA_DB_THUMBNAIL, MEDIA_DATA_DB_LCD };
1521 auto resultset = MediaLibraryFileOperations::QueryFileOperation(cmd, columns);
1522 if (resultset == nullptr) {
1523 return E_HAS_DB_ERROR;
1524 }
1525
1526 vector<string> thumbnailKeys;
1527 int count = 0;
1528 while (resultset->GoToNextRow() == NativeRdb::E_OK && count < MAX_QUERY_THUMBNAIL_KEY_COUNT) {
1529 string thumbnailKey =
1530 get<string>(ResultSetUtils::GetValFromColumn(MEDIA_DATA_DB_THUMBNAIL, resultset, TYPE_STRING));
1531 thumbnailKeys.push_back(thumbnailKey);
1532 string lcdKey = get<string>(ResultSetUtils::GetValFromColumn(MEDIA_DATA_DB_LCD, resultset, TYPE_STRING));
1533 thumbnailKeys.push_back(lcdKey);
1534 count++;
1535 }
1536
1537 if (thumbnailKeys.empty()) {
1538 return E_NO_SUCH_FILE;
1539 }
1540 MediaLibrarySyncOperation::SyncPullKvstore(kvStorePtr_, thumbnailKeys,
1541 MediaFileUtils::GetNetworkIdFromUri(uri.ToString()));
1542 return E_SUCCESS;
1543 }
1544 #endif
1545
1546 static const map<OperationObject, string> QUERY_CONDITION_MAP {
1547 { OperationObject::SMART_ALBUM, SMARTALBUM_DB_ID },
1548 { OperationObject::SMART_ALBUM_MAP, SMARTALBUMMAP_DB_ALBUM_ID },
1549 { OperationObject::FILESYSTEM_DIR, MEDIA_DATA_DB_ID },
1550 { OperationObject::ALL_DEVICE, "" },
1551 { OperationObject::ACTIVE_DEVICE, "" },
1552 { OperationObject::ASSETMAP, "" },
1553 { OperationObject::SMART_ALBUM_ASSETS, "" },
1554 { OperationObject::BUNDLE_PERMISSION, "" },
1555 };
1556
CheckIsPortraitAlbum(MediaLibraryCommand & cmd)1557 bool CheckIsPortraitAlbum(MediaLibraryCommand &cmd)
1558 {
1559 auto predicates = cmd.GetAbsRdbPredicates();
1560 auto whereClause = predicates->GetWhereClause();
1561 if (whereClause.find(USER_DISPLAY_LEVEL) != string::npos || whereClause.find(IS_ME) != string::npos ||
1562 whereClause.find(ALBUM_NAME_NOT_NULL) != string::npos) {
1563 return true;
1564 }
1565 return false;
1566 }
1567
QuerySet(MediaLibraryCommand & cmd,const vector<string> & columns,const DataSharePredicates & predicates,int & errCode)1568 shared_ptr<NativeRdb::ResultSet> MediaLibraryDataManager::QuerySet(MediaLibraryCommand &cmd,
1569 const vector<string> &columns, const DataSharePredicates &predicates, int &errCode)
1570 {
1571 MediaLibraryTracer tracer;
1572 tracer.Start("QueryRdb");
1573 tracer.Start("CheckWhereClause");
1574 MEDIA_DEBUG_LOG("CheckWhereClause start %{public}s", cmd.GetUri().ToString().c_str());
1575 auto whereClause = predicates.GetWhereClause();
1576 if (!MediaLibraryCommonUtils::CheckWhereClause(whereClause)) {
1577 errCode = E_INVALID_VALUES;
1578 MEDIA_ERR_LOG("illegal query whereClause input %{private}s", whereClause.c_str());
1579 VariantMap map = {{KEY_ERR_FILE, __FILE__}, {KEY_ERR_LINE, __LINE__}, {KEY_ERR_CODE, errCode},
1580 {KEY_OPT_TYPE, OptType::QUERY}};
1581 PostEventUtils::GetInstance().PostErrorProcess(ErrType::DB_OPT_ERR, map);
1582 return nullptr;
1583 }
1584 MEDIA_DEBUG_LOG("CheckWhereClause end");
1585 tracer.Finish();
1586
1587 cmd.SetDataSharePred(predicates);
1588 // MEDIALIBRARY_TABLE just for RdbPredicates
1589 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, MEDIALIBRARY_TABLE);
1590 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
1591 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
1592 cmd.GetAbsRdbPredicates()->SetOrder(rdbPredicate.GetOrder());
1593 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(const_cast<vector<string> &>(columns));
1594
1595 OperationObject oprnObject = cmd.GetOprnObject();
1596 auto it = QUERY_CONDITION_MAP.find(oprnObject);
1597 if (it != QUERY_CONDITION_MAP.end()) {
1598 return MediaLibraryObjectUtils::QueryWithCondition(cmd, columns, it->second);
1599 }
1600
1601 return QueryInternal(cmd, columns, predicates);
1602 }
1603
QueryAnalysisAlbum(MediaLibraryCommand & cmd,const vector<string> & columns,const DataSharePredicates & predicates)1604 shared_ptr<NativeRdb::ResultSet> QueryAnalysisAlbum(MediaLibraryCommand &cmd,
1605 const vector<string> &columns, const DataSharePredicates &predicates)
1606 {
1607 RdbPredicates rdbPredicates = RdbUtils::ToPredicates(predicates, cmd.GetTableName());
1608 int32_t albumSubtype = MediaLibraryRdbUtils::GetAlbumSubtypeArgument(rdbPredicates);
1609 MEDIA_DEBUG_LOG("Query analysis album of subtype: %{public}d", albumSubtype);
1610 if (albumSubtype == PhotoAlbumSubType::GROUP_PHOTO) {
1611 return MediaLibraryAnalysisAlbumOperations::QueryGroupPhotoAlbum(cmd, columns);
1612 }
1613 if (CheckIsPortraitAlbum(cmd)) {
1614 return MediaLibraryAlbumOperations::QueryPortraitAlbum(cmd, columns);
1615 }
1616 return MediaLibraryRdbStore::QueryWithFilter(rdbPredicates, columns);
1617 }
1618
QueryInternal(MediaLibraryCommand & cmd,const vector<string> & columns,const DataSharePredicates & predicates)1619 shared_ptr<NativeRdb::ResultSet> MediaLibraryDataManager::QueryInternal(MediaLibraryCommand &cmd,
1620 const vector<string> &columns, const DataSharePredicates &predicates)
1621 {
1622 MediaLibraryTracer tracer;
1623 switch (cmd.GetOprnObject()) {
1624 case OperationObject::FILESYSTEM_ALBUM:
1625 case OperationObject::MEDIA_VOLUME:
1626 return MediaLibraryAlbumOperations::QueryAlbumOperation(cmd, columns);
1627 case OperationObject::INDEX_CONSTRUCTION_STATUS:
1628 return MediaLibrarySearchOperations::QueryIndexConstructProgress();
1629 case OperationObject::PHOTO_ALBUM:
1630 return MediaLibraryAlbumOperations::QueryPhotoAlbum(cmd, columns);
1631 case OperationObject::ANALYSIS_PHOTO_ALBUM:
1632 return QueryAnalysisAlbum(cmd, columns, predicates);
1633 case OperationObject::PHOTO_MAP:
1634 case OperationObject::ANALYSIS_PHOTO_MAP: {
1635 return PhotoMapOperations::QueryPhotoAssets(
1636 RdbUtils::ToPredicates(predicates, PhotoColumn::PHOTOS_TABLE), columns);
1637 }
1638 case OperationObject::FILESYSTEM_PHOTO:
1639 case OperationObject::FILESYSTEM_AUDIO:
1640 case OperationObject::PAH_MOVING_PHOTO:
1641 return MediaLibraryAssetOperations::QueryOperation(cmd, columns);
1642 case OperationObject::VISION_START ... OperationObject::VISION_END:
1643 return MediaLibraryRdbStore::QueryWithFilter(RdbUtils::ToPredicates(predicates, cmd.GetTableName()),
1644 columns);
1645 case OperationObject::GEO_DICTIONARY:
1646 case OperationObject::GEO_KNOWLEDGE:
1647 case OperationObject::GEO_PHOTO:
1648 return MediaLibraryRdbStore::Query(RdbUtils::ToPredicates(predicates, cmd.GetTableName()), columns);
1649 case OperationObject::SEARCH_TOTAL:
1650 return MediaLibraryRdbStore::Query(RdbUtils::ToPredicates(predicates, cmd.GetTableName()), columns);
1651 case OperationObject::STORY_ALBUM:
1652 case OperationObject::STORY_COVER:
1653 case OperationObject::STORY_PLAY:
1654 case OperationObject::USER_PHOTOGRAPHY:
1655 return MediaLibraryRdbStore::Query(RdbUtils::ToPredicates(predicates, cmd.GetTableName()), columns);
1656 case OperationObject::APP_URI_PERMISSION_INNER:
1657 return MediaLibraryRdbStore::QueryWithFilter(RdbUtils::ToPredicates(predicates, cmd.GetTableName()),
1658 columns);
1659 case OperationObject::PAH_MULTISTAGES_CAPTURE:
1660 return MultiStagesPhotoCaptureManager::GetInstance().HandleMultiStagesOperation(cmd, columns);
1661 case OperationObject::PAH_CLOUD_ENHANCEMENT_OPERATE:
1662 return EnhancementManager::GetInstance().HandleEnhancementQueryOperation(cmd, columns);
1663 case OperationObject::TAB_OLD_PHOTO:
1664 return MediaLibraryTabOldPhotosOperations().Query(
1665 RdbUtils::ToPredicates(predicates, TabOldPhotosColumn::OLD_PHOTOS_TABLE), columns);
1666 default:
1667 tracer.Start("QueryFile");
1668 return MediaLibraryFileOperations::QueryFileOperation(cmd, columns);
1669 }
1670 }
1671
QueryRdb(MediaLibraryCommand & cmd,const vector<string> & columns,const DataSharePredicates & predicates,int & errCode)1672 shared_ptr<NativeRdb::ResultSet> MediaLibraryDataManager::QueryRdb(MediaLibraryCommand &cmd,
1673 const vector<string> &columns, const DataSharePredicates &predicates, int &errCode)
1674 {
1675 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1676 if (refCnt_.load() <= 0) {
1677 errCode = E_FAIL;
1678 VariantMap map = {{KEY_ERR_FILE, __FILE__}, {KEY_ERR_LINE, __LINE__}, {KEY_ERR_CODE, errCode},
1679 {KEY_OPT_TYPE, OptType::QUERY}};
1680 PostEventUtils::GetInstance().PostErrorProcess(ErrType::DB_OPT_ERR, map);
1681 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1682 return nullptr;
1683 }
1684
1685 return QuerySet(cmd, columns, predicates, errCode);
1686 }
1687
1688 #ifdef DISTRIBUTED
QuerySync(const string & networkId,const string & tableName)1689 bool MediaLibraryDataManager::QuerySync(const string &networkId, const string &tableName)
1690 {
1691 if (networkId.empty() || tableName.empty()) {
1692 return false;
1693 }
1694
1695 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
1696 auto &deviceManager = OHOS::DistributedHardware::DeviceManager::GetInstance();
1697 auto ret = deviceManager.GetLocalDeviceInfo(bundleName_, deviceInfo);
1698 if (ret != ERR_OK) {
1699 MEDIA_ERR_LOG("MediaLibraryDataManager QuerySync Failed to get local device info.");
1700 return false;
1701 }
1702
1703 if (networkId == string(deviceInfo.networkId)) {
1704 return true;
1705 }
1706
1707 int32_t syncStatus = DEVICE_SYNCSTATUSING;
1708 auto result = MediaLibraryDevice::GetInstance()->GetDeviceSyncStatus(networkId, tableName, syncStatus);
1709 if (result && syncStatus == DEVICE_SYNCSTATUS_COMPLETE) {
1710 return true;
1711 }
1712
1713 vector<string> devices = { networkId };
1714 MediaLibrarySyncOpts syncOpts;
1715 syncOpts.rdbStore = rdbStore_;
1716 syncOpts.table = tableName;
1717 syncOpts.bundleName = bundleName_;
1718 return MediaLibrarySyncOperation::SyncPullTable(syncOpts, devices);
1719 }
1720 #endif
1721
OpenFile(MediaLibraryCommand & cmd,const string & mode)1722 int32_t MediaLibraryDataManager::OpenFile(MediaLibraryCommand &cmd, const string &mode)
1723 {
1724 MediaLibraryTracer tracer;
1725 tracer.Start("MediaLibraryDataManager::OpenFile");
1726 auto oprnObject = cmd.GetOprnObject();
1727 if (oprnObject == OperationObject::FILESYSTEM_PHOTO || oprnObject == OperationObject::FILESYSTEM_AUDIO ||
1728 oprnObject == OperationObject::HIGHLIGHT_COVER || oprnObject == OperationObject::HIGHLIGHT_URI) {
1729 return MediaLibraryAssetOperations::OpenOperation(cmd, mode);
1730 }
1731
1732 #ifdef MEDIALIBRARY_COMPATIBILITY
1733 if (oprnObject != OperationObject::THUMBNAIL && oprnObject != OperationObject::THUMBNAIL_ASTC &&
1734 oprnObject != OperationObject::REQUEST_PICTURE && oprnObject != OperationObject::PHOTO_REQUEST_PICTURE_BUFFER) {
1735 string opObject = MediaFileUri::GetPathFirstDentry(const_cast<Uri &>(cmd.GetUri()));
1736 if (opObject == IMAGE_ASSET_TYPE || opObject == VIDEO_ASSET_TYPE || opObject == URI_TYPE_PHOTO) {
1737 cmd.SetOprnObject(OperationObject::FILESYSTEM_PHOTO);
1738 return MediaLibraryAssetOperations::OpenOperation(cmd, mode);
1739 }
1740 if (opObject == AUDIO_ASSET_TYPE || opObject == URI_TYPE_AUDIO_V10) {
1741 cmd.SetOprnObject(OperationObject::FILESYSTEM_AUDIO);
1742 return MediaLibraryAssetOperations::OpenOperation(cmd, mode);
1743 }
1744 }
1745 #endif
1746
1747 return MediaLibraryObjectUtils::OpenFile(cmd, mode);
1748 }
1749
NotifyChange(const Uri & uri)1750 void MediaLibraryDataManager::NotifyChange(const Uri &uri)
1751 {
1752 shared_lock<shared_mutex> sharedLock(mgrSharedMutex_);
1753 if (refCnt_.load() <= 0) {
1754 MEDIA_DEBUG_LOG("MediaLibraryDataManager is not initialized");
1755 return;
1756 }
1757
1758 if (extension_ == nullptr) {
1759 MEDIA_ERR_LOG("MediaLibraryDataManager::NotifyChange failed");
1760 return;
1761 }
1762
1763 extension_->NotifyChange(uri);
1764 }
1765
InitialiseThumbnailService(const shared_ptr<OHOS::AbilityRuntime::Context> & extensionContext)1766 int32_t MediaLibraryDataManager::InitialiseThumbnailService(
1767 const shared_ptr<OHOS::AbilityRuntime::Context> &extensionContext)
1768 {
1769 if (thumbnailService_ != nullptr) {
1770 return E_OK;
1771 }
1772 thumbnailService_ = ThumbnailService::GetInstance();
1773 if (thumbnailService_ == nullptr) {
1774 return E_THUMBNAIL_SERVICE_NULLPTR;
1775 }
1776 #ifdef DISTRIBUTED
1777 thumbnailService_->Init(rdbStore_, kvStorePtr_, extensionContext);
1778 #else
1779 thumbnailService_->Init(rdbStore_, extensionContext);
1780 #endif
1781 return E_OK;
1782 }
1783
InitACLPermission()1784 void MediaLibraryDataManager::InitACLPermission()
1785 {
1786 if (access(THUMB_DIR.c_str(), F_OK) == 0) {
1787 return;
1788 }
1789
1790 if (!MediaFileUtils::CreateDirectory(THUMB_DIR)) {
1791 MEDIA_ERR_LOG("Failed create thumbs Photo dir");
1792 return;
1793 }
1794
1795 if (Acl::AclSetDefault() != E_OK) {
1796 MEDIA_ERR_LOG("Failed to set the acl read permission for the thumbs Photo dir");
1797 }
1798 }
1799
InitDatabaseACLPermission()1800 void MediaLibraryDataManager::InitDatabaseACLPermission()
1801 {
1802 if (access(RDB_DIR.c_str(), F_OK) != E_OK) {
1803 if (!MediaFileUtils::CreateDirectory(RDB_DIR)) {
1804 MEDIA_ERR_LOG("Failed create media rdb dir");
1805 return;
1806 }
1807 }
1808
1809 if (access(KVDB_DIR.c_str(), F_OK) != E_OK) {
1810 if (!MediaFileUtils::CreateDirectory(KVDB_DIR)) {
1811 MEDIA_ERR_LOG("Failed create media kvdb dir");
1812 return;
1813 }
1814 }
1815
1816 if (Acl::AclSetDatabase() != E_OK) {
1817 MEDIA_ERR_LOG("Failed to set the acl db permission for the media db dir");
1818 }
1819 }
1820
OnScanFinished(const int32_t status,const string & uri,const string & path)1821 int32_t ScanFileCallback::OnScanFinished(const int32_t status, const string &uri, const string &path)
1822 {
1823 auto instance = MediaLibraryDataManager::GetInstance();
1824 if (instance != nullptr) {
1825 instance->CreateThumbnailAsync(uri, path);
1826 }
1827 return E_OK;
1828 }
1829
SetCmdBundleAndDevice(MediaLibraryCommand & outCmd)1830 int32_t MediaLibraryDataManager::SetCmdBundleAndDevice(MediaLibraryCommand &outCmd)
1831 {
1832 string clientBundle = MediaLibraryBundleManager::GetInstance()->GetClientBundleName();
1833 if (clientBundle.empty()) {
1834 MEDIA_ERR_LOG("GetClientBundleName failed");
1835 return E_GET_CLIENTBUNDLE_FAIL;
1836 }
1837 outCmd.SetBundleName(clientBundle);
1838 #ifdef DISTRIBUTED
1839 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
1840 auto &deviceManager = OHOS::DistributedHardware::DeviceManager::GetInstance();
1841 int32_t ret = deviceManager.GetLocalDeviceInfo(bundleName_, deviceInfo);
1842 if (ret < 0) {
1843 MEDIA_ERR_LOG("GetLocalDeviceInfo ret = %{public}d", ret);
1844 } else {
1845 outCmd.SetDeviceName(deviceInfo.deviceName);
1846 }
1847 return ret;
1848 #endif
1849 return 0;
1850 }
1851
DoTrashAging(shared_ptr<int> countPtr)1852 int32_t MediaLibraryDataManager::DoTrashAging(shared_ptr<int> countPtr)
1853 {
1854 shared_ptr<int> smartAlbumTrashPtr = make_shared<int>();
1855 MediaLibrarySmartAlbumMapOperations::HandleAgingOperation(smartAlbumTrashPtr);
1856
1857 shared_ptr<int> albumTrashtPtr = make_shared<int>();
1858 MediaLibraryAlbumOperations::HandlePhotoAlbum(OperationType::AGING, {}, {}, albumTrashtPtr);
1859
1860 shared_ptr<int> audioTrashtPtr = make_shared<int>();
1861 MediaLibraryAudioOperations::TrashAging(audioTrashtPtr);
1862
1863 if (countPtr != nullptr) {
1864 *countPtr = *smartAlbumTrashPtr + *albumTrashtPtr + *audioTrashtPtr;
1865 }
1866 return E_SUCCESS;
1867 }
1868
RevertPendingByFileId(const std::string & fileId)1869 int32_t MediaLibraryDataManager::RevertPendingByFileId(const std::string &fileId)
1870 {
1871 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_ASSET, OperationType::UPDATE);
1872 ValuesBucket values;
1873 values.PutLong(Media::MEDIA_DATA_DB_TIME_PENDING, 0);
1874 cmd.SetValueBucket(values);
1875 int32_t retVal = MediaLibraryObjectUtils::ModifyInfoByIdInDb(cmd, fileId);
1876 if (retVal <= 0) {
1877 MEDIA_ERR_LOG("failed to revert pending error, fileId:%{private}s", fileId.c_str());
1878 return retVal;
1879 }
1880 auto fileAsset = MediaLibraryObjectUtils::GetFileAssetFromId(fileId);
1881 string srcPath = fileAsset->GetPath();
1882 MediaLibraryObjectUtils::ScanFileAsync(srcPath, fileId, MediaLibraryApi::API_10);
1883 return E_SUCCESS;
1884 }
1885
RevertPendingByPackage(const std::string & bundleName)1886 int32_t MediaLibraryDataManager::RevertPendingByPackage(const std::string &bundleName)
1887 {
1888 MediaLibraryCommand queryCmd(OperationObject::FILESYSTEM_ASSET, OperationType::QUERY);
1889 queryCmd.GetAbsRdbPredicates()
1890 ->EqualTo(MEDIA_DATA_DB_OWNER_PACKAGE, bundleName)
1891 ->And()
1892 ->NotEqualTo(MEDIA_DATA_DB_TIME_PENDING, to_string(0));
1893 vector<string> columns = { MEDIA_DATA_DB_ID };
1894 auto result = MediaLibraryObjectUtils::QueryWithCondition(queryCmd, columns);
1895 if (result == nullptr) {
1896 return E_HAS_DB_ERROR;
1897 }
1898
1899 int32_t ret = E_SUCCESS;
1900 while (result->GoToNextRow() == NativeRdb::E_OK) {
1901 int32_t id = GetInt32Val(MEDIA_DATA_DB_ID, result);
1902 int32_t retVal = RevertPendingByFileId(to_string(id));
1903 if (retVal != E_SUCCESS) {
1904 ret = retVal;
1905 MEDIA_ERR_LOG("Revert file %{public}d failed, ret=%{public}d", id, retVal);
1906 continue;
1907 }
1908 }
1909 return ret;
1910 }
1911
SetStartupParameter()1912 void MediaLibraryDataManager::SetStartupParameter()
1913 {
1914 static constexpr uint32_t BASE_USER_RANGE = 200000; // for get uid
1915 uid_t uid = getuid() / BASE_USER_RANGE;
1916 const string key = "multimedia.medialibrary.startup." + to_string(uid);
1917 string value = "true";
1918 int32_t ret = SetParameter(key.c_str(), value.c_str());
1919 if (ret != 0) {
1920 MEDIA_ERR_LOG("Failed to set startup, result: %{public}d", ret);
1921 } else {
1922 MEDIA_INFO_LOG("Set startup success: %{public}s", to_string(uid).c_str());
1923 }
1924 // init backup param
1925 std::string backupParam = "persist.multimedia.medialibrary.rdb_switch_status";
1926 ret = system::SetParameter(backupParam, "0");
1927 if (ret != 0) {
1928 MEDIA_ERR_LOG("Failed to set parameter backup, ret:%{public}d", ret);
1929 }
1930 std::string nextFlag = "persist.update.hmos_to_next_flag";
1931 auto isUpgrade = system::GetParameter(nextFlag, "");
1932 MEDIA_INFO_LOG("isUpgrade:%{public}s", isUpgrade.c_str());
1933 if (isUpgrade != "1") {
1934 return;
1935 }
1936 std::string CLONE_FLAG = "multimedia.medialibrary.cloneFlag";
1937 auto currentTime = to_string(MediaFileUtils::UTCTimeSeconds());
1938 MEDIA_INFO_LOG("SetParameterForClone currentTime:%{public}s", currentTime.c_str());
1939 bool retFlag = system::SetParameter(CLONE_FLAG, currentTime);
1940 if (!retFlag) {
1941 MEDIA_ERR_LOG("Failed to set parameter cloneFlag, retFlag:%{public}d", retFlag);
1942 }
1943 }
1944
ProcessThumbnailBatchCmd(const MediaLibraryCommand & cmd,const NativeRdb::ValuesBucket & value,const DataShare::DataSharePredicates & predicates)1945 int32_t MediaLibraryDataManager::ProcessThumbnailBatchCmd(const MediaLibraryCommand &cmd,
1946 const NativeRdb::ValuesBucket &value, const DataShare::DataSharePredicates &predicates)
1947 {
1948 if (thumbnailService_ == nullptr) {
1949 return E_THUMBNAIL_SERVICE_NULLPTR;
1950 }
1951
1952 int32_t requestId = 0;
1953 ValueObject valueObject;
1954 if (value.GetObject(THUMBNAIL_BATCH_GENERATE_REQUEST_ID, valueObject)) {
1955 valueObject.GetInt(requestId);
1956 }
1957
1958 if (cmd.GetOprnType() == OperationType::START_GENERATE_THUMBNAILS) {
1959 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, PhotoColumn::PHOTOS_TABLE);
1960 return thumbnailService_->CreateAstcBatchOnDemand(rdbPredicate, requestId);
1961 } else if (cmd.GetOprnType() == OperationType::STOP_GENERATE_THUMBNAILS) {
1962 thumbnailService_->CancelAstcBatchTask(requestId);
1963 return E_OK;
1964 } else if (cmd.GetOprnType() == OperationType::GENERATE_THUMBNAILS_RESTORE) {
1965 return thumbnailService_->RestoreThumbnailDualFrame();
1966 } else {
1967 MEDIA_ERR_LOG("invalid mediaLibrary command");
1968 return E_INVALID_ARGUMENTS;
1969 }
1970 }
1971
CheckCloudThumbnailDownloadFinish()1972 int32_t MediaLibraryDataManager::CheckCloudThumbnailDownloadFinish()
1973 {
1974 if (thumbnailService_ == nullptr) {
1975 MEDIA_ERR_LOG("thumbanilService is nullptr");
1976 return E_THUMBNAIL_SERVICE_NULLPTR;
1977 }
1978
1979 return thumbnailService_->CheckCloudThumbnailDownloadFinish();
1980 }
1981
UploadDBFileInner()1982 void MediaLibraryDataManager::UploadDBFileInner()
1983 {
1984 auto rdbStore = MediaLibraryUnistoreManager::GetInstance().GetRdbStore();
1985 if (rdbStore == nullptr) {
1986 MEDIA_ERR_LOG("rdbStore is nullptr!");
1987 return;
1988 }
1989
1990 std::string destPath = "/data/storage/el2/log/logpack/media_library.db";
1991 std::string tmpPath = MEDIA_DB_DIR + "/rdb/media_library_tmp.db";
1992 int32_t errCode = rdbStore->Backup(tmpPath);
1993 if (errCode != 0) {
1994 MEDIA_ERR_LOG("rdb backup fail: %{public}d", errCode);
1995 return;
1996 }
1997 MediaFileUtils::CopyFileUtil(tmpPath, destPath);
1998 }
1999
SubscriberPowerConsumptionDetection()2000 void MediaLibraryDataManager::SubscriberPowerConsumptionDetection()
2001 {
2002 #ifdef DEVICE_STANDBY_ENABLE
2003 auto subscriber = new (std::nothrow) MediaLibraryStandbyServiceSubscriber();
2004 subscriber->SetSubscriberName(SUBSCRIBER_NAME);
2005 subscriber->SetModuleName(MODULE_NAME);
2006 DevStandbyMgr::StandbyServiceClient::GetInstance().SubscribeStandbyCallback(subscriber);
2007 #endif
2008 }
2009 } // namespace Media
2010 } // namespace OHOS
2011