1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define MLOG_TAG "DataManager"
16
17 #include "medialibrary_data_manager.h"
18
19 #include <unordered_set>
20 #include <shared_mutex>
21
22 #include "abs_rdb_predicates.h"
23 #include "datashare_abs_result_set.h"
24 #include "device_manager.h"
25 #include "device_manager_callback.h"
26 #include "hitrace_meter.h"
27 #include "ipc_skeleton.h"
28 #include "media_datashare_ext_ability.h"
29 #include "media_file_utils.h"
30 #include "media_log.h"
31 #include "media_scanner_manager.h"
32 #include "medialibrary_album_operations.h"
33 #include "medialibrary_uripermission_operations.h"
34 #include "medialibrary_common_utils.h"
35 #include "medialibrary_device.h"
36 #include "medialibrary_device_info.h"
37 #include "medialibrary_dir_operations.h"
38 #include "medialibrary_errno.h"
39 #include "medialibrary_file_operations.h"
40 #include "medialibrary_object_utils.h"
41 #include "medialibrary_smartalbum_map_operations.h"
42 #include "medialibrary_smartalbum_operations.h"
43 #include "medialibrary_sync_table.h"
44 #include "medialibrary_unistore_manager.h"
45 #include "medialibrary_tracer.h"
46 #include "rdb_store.h"
47 #include "rdb_utils.h"
48 #include "system_ability_definition.h"
49 #include "timer.h"
50 #include "permission_utils.h"
51
52 using namespace std;
53 using namespace OHOS::AppExecFwk;
54 using namespace OHOS::AbilityRuntime;
55 using namespace OHOS::NativeRdb;
56 using namespace OHOS::DistributedKv;
57 using namespace OHOS::DataShare;
58 using namespace OHOS::RdbDataShareAdapter;
59
60 namespace {
61 const OHOS::DistributedKv::AppId KVSTORE_APPID = {"com.ohos.medialibrary.medialibrarydata"};
62 const OHOS::DistributedKv::StoreId KVSTORE_STOREID = {"medialibrary_thumbnail"};
63 };
64
65 namespace OHOS {
66 namespace Media {
67
68 std::shared_ptr<MediaLibraryDataManager> MediaLibraryDataManager::instance_ = nullptr;
69 std::mutex MediaLibraryDataManager::mutex_;
70
MediaLibraryDataManager(void)71 MediaLibraryDataManager::MediaLibraryDataManager(void)
72 {
73 }
74
~MediaLibraryDataManager(void)75 MediaLibraryDataManager::~MediaLibraryDataManager(void)
76 {
77 if (kvStorePtr_ != nullptr) {
78 dataManager_.CloseKvStore(KVSTORE_APPID, kvStorePtr_);
79 kvStorePtr_ = nullptr;
80 }
81 }
82
GetInstance()83 std::shared_ptr<MediaLibraryDataManager> MediaLibraryDataManager::GetInstance()
84 {
85 if (instance_ == nullptr) {
86 std::lock_guard<std::mutex> lock(mutex_);
87 if (instance_ == nullptr) {
88 instance_ = std::make_shared<MediaLibraryDataManager>();
89 }
90 }
91 return instance_;
92 }
93
MediaDataShareCreator(const std::unique_ptr<Runtime> & runtime)94 static DataShare::DataShareExtAbility *MediaDataShareCreator(const std::unique_ptr<Runtime> &runtime)
95 {
96 MEDIA_DEBUG_LOG("MediaLibraryCreator::%{public}s", __func__);
97 return MediaDataShareExtAbility::Create(runtime);
98 }
99
RegisterDataShareCreator()100 __attribute__((constructor)) void RegisterDataShareCreator()
101 {
102 MEDIA_DEBUG_LOG("MediaLibraryDataMgr::%{public}s", __func__);
103 DataShare::DataShareExtAbility::SetCreator(MediaDataShareCreator);
104 }
105
MakeRootDirs()106 static void MakeRootDirs()
107 {
108 for (auto &dir : PRESET_ROOT_DIRS) {
109 Uri createAlbumUri(MEDIALIBRARY_DATA_URI + "/" + MEDIA_ALBUMOPRN + "/" + MEDIA_ALBUMOPRN_CREATEALBUM);
110 ValuesBucket valuesBucket;
111 valuesBucket.PutString(MEDIA_DATA_DB_FILE_PATH, ROOT_MEDIA_DIR + dir);
112 MediaLibraryCommand cmd(createAlbumUri, valuesBucket);
113 auto ret = MediaLibraryAlbumOperations::CreateAlbumOperation(cmd);
114 if (ret <= 0) {
115 MEDIA_ERR_LOG("Failed to preset root dir: %{public}s", dir.c_str());
116 }
117 MediaFileUtils::CreateDirectory(ROOT_MEDIA_DIR + dir + ".recycle");
118 }
119 }
120
InitMediaLibraryMgr(const std::shared_ptr<OHOS::AbilityRuntime::Context> & context,const std::shared_ptr<OHOS::AbilityRuntime::Context> & extensionContext)121 void MediaLibraryDataManager::InitMediaLibraryMgr(const std::shared_ptr<OHOS::AbilityRuntime::Context> &context,
122 const std::shared_ptr<OHOS::AbilityRuntime::Context> &extensionContext)
123 {
124 std::lock_guard<std::shared_mutex> lock(mgrSharedMutex_);
125
126 refCnt_++;
127 if (refCnt_.load() > 1) {
128 MEDIA_DEBUG_LOG("already initialized");
129 return;
130 }
131
132 context_ = context;
133 InitMediaLibraryRdbStore();
134 InitDeviceData();
135 MakeDirQuerySetMap(dirQuerySetMap_);
136 MakeRootDirs();
137 InitialiseKvStore();
138 InitialiseThumbnailService(extensionContext);
139 }
140
InitDeviceData()141 void MediaLibraryDataManager::InitDeviceData()
142 {
143 if (rdbStore_ == nullptr) {
144 MEDIA_ERR_LOG("MediaLibraryDataManager InitDeviceData rdbStore is null");
145 return;
146 }
147
148 MediaLibraryTracer tracer;
149 tracer.Start("InitDeviceRdbStoreTrace");
150 if (!MediaLibraryDevice::GetInstance()->InitDeviceRdbStore(rdbStore_)) {
151 MEDIA_ERR_LOG("MediaLibraryDataManager InitDeviceData failed!");
152 }
153 }
154
ClearMediaLibraryMgr()155 void MediaLibraryDataManager::ClearMediaLibraryMgr()
156 {
157 std::lock_guard<std::shared_mutex> lock(mgrSharedMutex_);
158
159 refCnt_--;
160 if (refCnt_.load() > 0) {
161 MEDIA_DEBUG_LOG("still other extension exist");
162 return;
163 }
164
165 rdbStore_ = nullptr;
166
167 if (kvStorePtr_ != nullptr) {
168 dataManager_.CloseKvStore(KVSTORE_APPID, kvStorePtr_);
169 kvStorePtr_ = nullptr;
170 }
171 if (MediaLibraryDevice::GetInstance()) {
172 MediaLibraryDevice::GetInstance()->Stop();
173 };
174 if (thumbnailService_ != nullptr) {
175 thumbnailService_->ReleaseService();
176 thumbnailService_ = nullptr;
177 }
178 MediaLibraryUnistoreManager::GetInstance().Stop();
179 extension_ = nullptr;
180 }
181
InitMediaLibraryRdbStore()182 int32_t MediaLibraryDataManager::InitMediaLibraryRdbStore()
183 {
184 if (rdbStore_) {
185 return E_SUCCESS;
186 }
187
188 MediaLibraryUnistoreManager::GetInstance().Init(context_);
189 rdbStore_ = MediaLibraryUnistoreManager::GetInstance().GetRdbStoreRaw()->GetRaw();
190
191 return E_SUCCESS;
192 }
193
InitialiseKvStore()194 void MediaLibraryDataManager::InitialiseKvStore()
195 {
196 if (kvStorePtr_ != nullptr) {
197 return;
198 }
199
200 Options options = {
201 .createIfMissing = true,
202 .encrypt = false,
203 .backup = false,
204 .autoSync = false,
205 .area = DistributedKv::Area::EL2,
206 .kvStoreType = KvStoreType::SINGLE_VERSION,
207 .baseDir = context_->GetDatabaseDir(),
208 };
209
210 Status status = dataManager_.GetSingleKvStore(options, KVSTORE_APPID, KVSTORE_STOREID, kvStorePtr_);
211 if (status != Status::SUCCESS || kvStorePtr_ == nullptr) {
212 MEDIA_INFO_LOG("MediaLibraryDataManager::InitialiseKvStore failed %{private}d", status);
213 }
214 }
215
GetOwner()216 std::shared_ptr<MediaDataShareExtAbility> MediaLibraryDataManager::GetOwner()
217 {
218 return extension_;
219 }
220
SetOwner(const std::shared_ptr<MediaDataShareExtAbility> & datashareExternsion)221 void MediaLibraryDataManager::SetOwner(const std::shared_ptr<MediaDataShareExtAbility> &datashareExternsion)
222 {
223 extension_ = datashareExternsion;
224 }
225
GetType(const Uri & uri)226 std::string MediaLibraryDataManager::GetType(const Uri &uri)
227 {
228 MEDIA_INFO_LOG("GetType uri: %{public}s", uri.ToString().c_str());
229 return "";
230 }
231
MakeDirQuerySetMap(unordered_map<string,DirAsset> & outDirQuerySetMap)232 void MediaLibraryDataManager::MakeDirQuerySetMap(unordered_map<string, DirAsset> &outDirQuerySetMap)
233 {
234 int32_t count = -1;
235 int32_t dirTypeVal = -1;
236 int32_t columnIndexDir, columnIndexMedia, columnIndexEx, columnIndexDirType;
237 string dirVal, mediaVal, exVal;
238 vector<string> columns;
239 shared_ptr<AbsSharedResultSet> queryResultSet;
240 AbsRdbPredicates dirAbsPred(MEDIATYPE_DIRECTORY_TABLE);
241 queryResultSet = rdbStore_->Query(dirAbsPred, columns);
242 auto ret = queryResultSet->GetRowCount(count);
243 if (ret != NativeRdb::E_OK) {
244 MEDIA_ERR_LOG("rdb failed");
245 return;
246 }
247 MEDIA_INFO_LOG("MakeDirQuerySetMap count = %{public}d", count);
248 if (count == 0) {
249 MEDIA_ERR_LOG("can not find any dirAsset");
250 return;
251 }
252 while (queryResultSet->GoToNextRow() == NativeRdb::E_OK) {
253 DirAsset dirAsset;
254 queryResultSet->GetColumnIndex(CATEGORY_MEDIATYPE_DIRECTORY_DB_DIRECTORY_TYPE, columnIndexDirType);
255 queryResultSet->GetInt(columnIndexDirType, dirTypeVal);
256 queryResultSet->GetColumnIndex(CATEGORY_MEDIATYPE_DIRECTORY_DB_DIRECTORY, columnIndexDir);
257 queryResultSet->GetString(columnIndexDir, dirVal);
258 queryResultSet->GetColumnIndex(CATEGORY_MEDIATYPE_DIRECTORY_DB_MEDIA_TYPE, columnIndexMedia);
259 queryResultSet->GetString(columnIndexMedia, mediaVal);
260 queryResultSet->GetColumnIndex(CATEGORY_MEDIATYPE_DIRECTORY_DB_EXTENSION, columnIndexEx);
261 queryResultSet->GetString(columnIndexEx, exVal);
262 dirAsset.SetDirType(dirTypeVal);
263 dirAsset.SetDirectory(dirVal);
264 dirAsset.SetMediaTypes(mediaVal);
265 dirAsset.SetExtensions(exVal);
266 MEDIA_INFO_LOG("dirTypeVal: %{public}d dirVal: %{private}s mediaVal: %{public}s exVal: %{public}s",
267 dirTypeVal, dirVal.c_str(), mediaVal.c_str(), exVal.c_str());
268 outDirQuerySetMap.insert(make_pair(dirVal, dirAsset));
269 }
270 MEDIA_DEBUG_LOG("MakeDirQuerySetMap OUT");
271 }
272
GetDirQuerySetMap() const273 std::unordered_map<std::string, DirAsset> MediaLibraryDataManager::GetDirQuerySetMap() const
274 {
275 return dirQuerySetMap_;
276 }
277
Insert(const Uri & uri,const DataShareValuesBucket & dataShareValue)278 int32_t MediaLibraryDataManager::Insert(const Uri &uri, const DataShareValuesBucket &dataShareValue)
279 {
280 MEDIA_DEBUG_LOG("MediaLibraryDataManager::Insert");
281 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
282
283 ValuesBucket value = RdbUtils::ToValuesBucket(dataShareValue);
284 if (value.IsEmpty()) {
285 MEDIA_ERR_LOG("MediaLibraryDataManager Insert: Input parameter is invalid");
286 return E_INVALID_VALUES;
287 }
288
289 MediaLibraryCommand cmd(uri, value);
290 // boardcast operation
291 if (cmd.GetOprnType() == OperationType::SCAN) {
292 string scanPath = ROOT_MEDIA_DIR;
293 return MediaScannerManager::GetInstance()->ScanDir(scanPath, nullptr);
294 } else if ((cmd.GetOprnType() == OperationType::CREATE) && !CheckFileNameValid(dataShareValue)) {
295 return E_FILE_NAME_INVALID;
296 }
297
298 int32_t result = E_FAIL;
299 vector<string> devices;
300 // after replace all xxxOperations following, remove "operationType"
301 string operationType = MediaLibraryDataManagerUtils::GetOperationType(uri.ToString());
302 switch (cmd.GetOprnObject()) {
303 case OperationObject::FILESYSTEM_ASSET: {
304 result = MediaLibraryFileOperations::HandleFileOperation(cmd);
305 break;
306 }
307 case OperationObject::FILESYSTEM_ALBUM: {
308 result = MediaLibraryAlbumOperations::CreateAlbumOperation(cmd);
309 break;
310 }
311 case OperationObject::FILESYSTEM_DIR: {
312 MediaLibraryDirOperations dirOprn;
313 result = dirOprn.HandleDirOperations(operationType, value, rdbStore_, dirQuerySetMap_);
314 MediaLibrarySyncTable::SyncPushTable(rdbStore_, bundleName_, MEDIALIBRARY_TABLE, devices);
315 break;
316 }
317 case OperationObject::SMART_ALBUM: {
318 MediaLibrarySmartAlbumOperations smartalbumOprn;
319 result = smartalbumOprn.HandleSmartAlbumOperations(operationType, value, rdbStore_);
320 MediaLibrarySyncTable::SyncPushTable(rdbStore_, bundleName_, MEDIALIBRARY_TABLE, devices);
321 break;
322 }
323 case OperationObject::SMART_ALBUM_MAP: {
324 MediaLibrarySmartAlbumMapOperations smartalbumMapOprn;
325 result = smartalbumMapOprn.HandleSmartAlbumMapOperations(operationType, value, rdbStore_, dirQuerySetMap_);
326 MediaLibrarySyncTable::SyncPushTable(rdbStore_, bundleName_, MEDIALIBRARY_TABLE, devices);
327 break;
328 }
329 case OperationObject::THUMBNAIL: {
330 result = HandleThumbnailOperations(cmd);
331 break;
332 }
333 case OperationObject::BUNDLE_PERMISSION: {
334 result = UriPermissionOperations::HandleUriPermOperations(cmd);
335 break;
336 }
337 default: {
338 result = MediaLibraryObjectUtils::InsertInDb(cmd);
339 MediaLibrarySyncTable::SyncPushTable(rdbStore_, bundleName_, MEDIALIBRARY_TABLE, devices);
340 break;
341 }
342 }
343 return result;
344 }
345
HandleThumbnailOperations(MediaLibraryCommand & cmd)346 int32_t MediaLibraryDataManager::HandleThumbnailOperations(MediaLibraryCommand &cmd)
347 {
348 int32_t result = E_FAIL;
349 switch (cmd.GetOprnType()) {
350 case OperationType::GENERATE:
351 result = thumbnailService_->GenerateThumbnails();
352 break;
353 case OperationType::AGING:
354 result = thumbnailService_->LcdAging();
355 break;
356 case OperationType::DISTRIBUTE_AGING:
357 result = DistributeDeviceAging();
358 break;
359 case OperationType::DISTRIBUTE_CREATE:
360 result = CreateThumbnail(cmd.GetValueBucket());
361 break;
362 default:
363 MEDIA_ERR_LOG("bad operation type %{public}u", cmd.GetOprnType());
364 }
365 return result;
366 }
367
BatchInsert(const Uri & uri,const vector<DataShareValuesBucket> & values)368 int32_t MediaLibraryDataManager::BatchInsert(const Uri &uri, const vector<DataShareValuesBucket> &values)
369 {
370 MEDIA_DEBUG_LOG("MediaLibraryDataManager::BatchInsert");
371 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
372
373 string uriString = uri.ToString();
374 if (uriString != MEDIALIBRARY_DATA_URI) {
375 MEDIA_ERR_LOG("MediaLibraryDataManager BatchInsert: Input parameter is invalid");
376 return E_INVALID_URI;
377 }
378 int32_t rowCount = 0;
379 for (auto it = values.begin(); it != values.end(); it++) {
380 if (Insert(uri, *it) >= 0) {
381 rowCount++;
382 }
383 }
384
385 return rowCount;
386 }
387
Delete(const Uri & uri,const DataSharePredicates & predicates)388 int32_t MediaLibraryDataManager::Delete(const Uri &uri, const DataSharePredicates &predicates)
389 {
390 MEDIA_DEBUG_LOG("MediaLibraryDataManager::Delete");
391 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
392
393 if (uri.ToString().find(MEDIALIBRARY_DATA_URI) == string::npos) {
394 MEDIA_ERR_LOG("MediaLibraryDataManager Delete: Not Data ability Uri");
395 return E_INVALID_URI;
396 }
397
398 MediaLibraryCommand cmd(uri, OperationType::DELETE);
399 cmd.GetAbsRdbPredicates()->SetWhereClause(predicates.GetWhereClause());
400 cmd.GetAbsRdbPredicates()->SetWhereArgs(predicates.GetWhereArgs());
401
402 vector<string> devices;
403 switch (cmd.GetOprnObject()) {
404 case OperationObject::FILESYSTEM_ASSET: {
405 auto ret = MediaLibraryFileOperations::DeleteFileOperation(cmd, dirQuerySetMap_);
406 MediaLibrarySyncTable::SyncPushTable(rdbStore_, bundleName_, MEDIALIBRARY_TABLE, devices);
407 return ret;
408 }
409 case OperationObject::FILESYSTEM_DIR:
410 // supply a DeleteDirOperation here to replace
411 // delete in the HandleDirOperations in Insert function, if need
412 break;
413 case OperationObject::FILESYSTEM_ALBUM: {
414 auto ret = MediaLibraryAlbumOperations::DeleteAlbumOperation(cmd);
415 MediaLibrarySyncTable::SyncPushTable(rdbStore_, bundleName_, MEDIALIBRARY_TABLE, devices);
416 return ret;
417 }
418 default:
419 break;
420 }
421
422 // DeleteInfoByIdInDb can finish the default delete of smartalbum and smartmap,
423 // so no need to distinct them in switch-case deliberately
424 return MediaLibraryObjectUtils::DeleteInfoByIdInDb(cmd);
425 }
426
Update(const Uri & uri,const DataShareValuesBucket & dataShareValue,const DataSharePredicates & predicates)427 int32_t MediaLibraryDataManager::Update(const Uri &uri, const DataShareValuesBucket &dataShareValue,
428 const DataSharePredicates &predicates)
429 {
430 MEDIA_DEBUG_LOG("MediaLibraryDataManager::Update");
431 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
432
433 ValuesBucket value = RdbUtils::ToValuesBucket(dataShareValue);
434 if (value.IsEmpty()) {
435 MEDIA_ERR_LOG("MediaLibraryDataManager Update:Input parameter is invalid ");
436 return E_INVALID_VALUES;
437 }
438
439 MediaLibraryCommand cmd(uri, value);
440 cmd.GetAbsRdbPredicates()->SetWhereClause(predicates.GetWhereClause());
441 cmd.GetAbsRdbPredicates()->SetWhereArgs(predicates.GetWhereArgs());
442
443 switch (cmd.GetOprnObject()) {
444 case OperationObject::FILESYSTEM_ASSET: {
445 auto ret = MediaLibraryFileOperations::ModifyFileOperation(cmd);
446 if (ret == E_SAME_PATH) {
447 break;
448 } else {
449 return ret;
450 }
451 }
452 case OperationObject::FILESYSTEM_DIR:
453 // supply a ModifyDirOperation here to replace
454 // modify in the HandleDirOperations in Insert function, if need
455 break;
456 case OperationObject::FILESYSTEM_ALBUM: {
457 return MediaLibraryAlbumOperations::ModifyAlbumOperation(cmd);
458 }
459 default:
460 break;
461 }
462 // ModifyInfoByIdInDb can finish the default update of smartalbum and smartmap,
463 // so no need to distinct them in switch-case deliberately
464 cmd.SetValueBucket(value);
465 return MediaLibraryObjectUtils::ModifyInfoByIdInDb(cmd);
466 }
467
InterruptBgworker()468 void MediaLibraryDataManager::InterruptBgworker()
469 {
470 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
471 if (thumbnailService_ == nullptr) {
472 MEDIA_ERR_LOG("thumbnailService_ is null");
473 return;
474 }
475 thumbnailService_->InterruptBgworker();
476 }
477
GenerateThumbnails()478 int32_t MediaLibraryDataManager::GenerateThumbnails()
479 {
480 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
481 if (thumbnailService_ == nullptr) {
482 MEDIA_ERR_LOG("thumbnailService_ is null");
483 return E_FAIL;
484 }
485 return thumbnailService_->GenerateThumbnails();
486 }
487
DoAging()488 int32_t MediaLibraryDataManager::DoAging()
489 {
490 MEDIA_DEBUG_LOG("MediaLibraryDataManager::DoAging IN");
491 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
492 if (thumbnailService_ == nullptr) {
493 MEDIA_ERR_LOG("thumbnailService_ is null");
494 return E_FAIL;
495 }
496 int32_t errorCode = thumbnailService_->LcdAging();
497 if (errorCode != 0) {
498 MEDIA_ERR_LOG("LcdAging exist error %{public}d", errorCode);
499 }
500
501 errorCode = DistributeDeviceAging();
502 if (errorCode != 0) {
503 MEDIA_ERR_LOG("DistributeDeviceAging exist error %{public}d", errorCode);
504 }
505
506 errorCode = LcdDistributeAging();
507 if (errorCode != 0) {
508 MEDIA_ERR_LOG("LcdDistributeAging exist error %{public}d", errorCode);
509 }
510
511 return errorCode;
512 }
513
LcdDistributeAging()514 int32_t MediaLibraryDataManager::LcdDistributeAging()
515 {
516 MEDIA_DEBUG_LOG("MediaLibraryDataManager::LcdDistributeAging IN");
517 auto deviceInstance = MediaLibraryDevice::GetInstance();
518 if ((thumbnailService_ == nullptr) || (deviceInstance == nullptr)) {
519 MEDIA_ERR_LOG("thumbnailService_ is null");
520 return E_FAIL;
521 }
522 int32_t result = E_SUCCESS;
523 vector<string> deviceUdids;
524 deviceInstance->QueryAllDeviceUdid(deviceUdids);
525 for (string &udid : deviceUdids) {
526 result = thumbnailService_->LcdDistributeAging(udid);
527 if (result != E_SUCCESS) {
528 MEDIA_ERR_LOG("LcdDistributeAging fail result is %{public}d", result);
529 break;
530 }
531 }
532 return result;
533 }
534
DistributeDeviceAging()535 int32_t MediaLibraryDataManager::DistributeDeviceAging()
536 {
537 MEDIA_DEBUG_LOG("MediaLibraryDataManager::DistributeDeviceAging IN");
538 auto deviceInstance = MediaLibraryDevice::GetInstance();
539 if ((thumbnailService_ == nullptr) || (deviceInstance == nullptr)) {
540 MEDIA_ERR_LOG("thumbnailService_ is null");
541 return E_FAIL;
542 }
543 int32_t result = E_FAIL;
544 vector<MediaLibraryDeviceInfo> deviceDataBaseList;
545 deviceInstance->QueryAgingDeviceInfos(deviceDataBaseList);
546 MEDIA_DEBUG_LOG("MediaLibraryDevice InitDeviceRdbStore deviceDataBaseList size = %{public}d",
547 (int) deviceDataBaseList.size());
548 for (MediaLibraryDeviceInfo deviceInfo : deviceDataBaseList) {
549 result = thumbnailService_->InvalidateDistributeThumbnail(deviceInfo.deviceUdid);
550 if (result != E_SUCCESS) {
551 MEDIA_ERR_LOG("invalidate fail %{public}d", result);
552 continue;
553 }
554 }
555 return result;
556 }
557
GenThumbnail(const string & uri)558 shared_ptr<ResultSetBridge> MediaLibraryDataManager::GenThumbnail(const string &uri)
559 {
560 if (thumbnailService_ == nullptr) {
561 MEDIA_ERR_LOG("thumbnailService_ is null");
562 return nullptr;
563 }
564 return thumbnailService_->GetThumbnail(uri);
565 }
566
CreateThumbnailAsync(const string & uri)567 void MediaLibraryDataManager::CreateThumbnailAsync(const string &uri)
568 {
569 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
570 if (thumbnailService_ == nullptr) {
571 MEDIA_ERR_LOG("thumbnailService_ is null");
572 return;
573 }
574 if (!uri.empty()) {
575 int32_t err = thumbnailService_->CreateThumbnailAsync(uri);
576 if (err != E_SUCCESS) {
577 MEDIA_ERR_LOG("ThumbnailService CreateThumbnailAsync failed : %{public}d", err);
578 }
579 }
580 }
581
CreateThumbnail(const ValuesBucket & values)582 int32_t MediaLibraryDataManager::CreateThumbnail(const ValuesBucket &values)
583 {
584 if (thumbnailService_ == nullptr) {
585 MEDIA_ERR_LOG("thumbnailService_ is null");
586 return E_ERR;
587 }
588 string actualUri;
589 ValueObject valueObject;
590
591 if (values.GetObject(MEDIA_DATA_DB_URI, valueObject)) {
592 valueObject.GetString(actualUri);
593 }
594
595 if (!actualUri.empty()) {
596 int32_t errorCode = thumbnailService_->CreateThumbnail(actualUri);
597 if (errorCode != E_OK) {
598 MEDIA_ERR_LOG("CreateThumbnail failed : %{public}d", errorCode);
599 return errorCode;
600 }
601 }
602 MEDIA_DEBUG_LOG("MediaLibraryDataManager CreateThumbnail: OUT");
603 return E_OK;
604 }
605
NeedQuerySync(const string & networkId,OperationObject oprnObject)606 void MediaLibraryDataManager::NeedQuerySync(const string &networkId, OperationObject oprnObject)
607 {
608 if (networkId.empty()) {
609 return;
610 }
611 // tabletype mapping into tablename
612 std::string tableName = MEDIALIBRARY_TABLE;
613 if (oprnObject == OperationObject::SMART_ALBUM) {
614 tableName = SMARTALBUM_TABLE;
615 } else if (oprnObject == OperationObject::SMART_ALBUM_MAP) {
616 tableName = SMARTALBUM_MAP_TABLE;
617 }
618
619 if ((oprnObject != OperationObject::ASSETMAP) && (oprnObject != OperationObject::SMART_ABLUM_ASSETS)) {
620 MediaLibraryTracer tracer;
621 tracer.Start("QuerySync");
622 auto ret = QuerySync(networkId, tableName);
623 MEDIA_INFO_LOG("MediaLibraryDataManager QuerySync result = %{private}d", ret);
624 }
625 }
626
Query(const Uri & uri,const vector<string> & columns,const DataSharePredicates & predicates)627 shared_ptr<ResultSetBridge> MediaLibraryDataManager::Query(const Uri &uri,
628 const vector<string> &columns, const DataSharePredicates &predicates)
629 {
630 MEDIA_DEBUG_LOG("MediaLibraryDataManager::Query");
631 MediaLibraryTracer tracer;
632 tracer.Start("MediaLibraryDataManager::Query");
633 if (rdbStore_ == nullptr) {
634 MEDIA_ERR_LOG("Rdb Store is not initialized");
635 return nullptr;
636 }
637
638 auto whereClause = predicates.GetWhereClause();
639 if (!MediaLibraryCommonUtils::CheckWhereClause(whereClause)) {
640 MEDIA_ERR_LOG("illegal query whereClause input %{public}s", whereClause.c_str());
641 return nullptr;
642 }
643
644 MediaLibraryCommand cmd(uri, OperationType::QUERY);
645 cmd.GetAbsRdbPredicates()->SetWhereClause(whereClause);
646 cmd.GetAbsRdbPredicates()->SetWhereArgs(predicates.GetWhereArgs());
647 cmd.GetAbsRdbPredicates()->SetOrder(predicates.GetOrder());
648
649 string networkId = cmd.GetOprnDevice();
650 OperationObject oprnObject = cmd.GetOprnObject();
651 NeedQuerySync(networkId, oprnObject);
652
653 shared_ptr<ResultSetBridge> queryResultSet;
654 if (cmd.GetOprnObject() == OperationObject::THUMBNAIL) {
655 string uriString = uri.ToString();
656 if (!ThumbnailService::ParseThumbnailInfo(uriString)) {
657 return nullptr;
658 }
659 tracer.Start("GenThumbnail");
660 queryResultSet = GenThumbnail(uriString);
661 } else {
662 auto absResultSet = QueryRdb(uri, columns, predicates);
663 queryResultSet = RdbUtils::ToResultSetBridge(absResultSet);
664 }
665
666 return queryResultSet;
667 }
668
QueryRdb(const Uri & uri,const vector<string> & columns,const DataSharePredicates & predicates)669 shared_ptr<AbsSharedResultSet> MediaLibraryDataManager::QueryRdb(const Uri &uri, const vector<string> &columns,
670 const DataSharePredicates &predicates)
671 {
672 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
673 MediaLibraryTracer tracer;
674 tracer.Start("MediaLibraryDataManager::QueryRdb");
675 static const map<OperationObject, string> queryConditionMap {
676 { OperationObject::SMART_ALBUM, SMARTALBUM_DB_ID },
677 { OperationObject::SMART_ALBUM_MAP, SMARTALBUMMAP_DB_ALBUM_ID },
678 { OperationObject::FILESYSTEM_DIR, MEDIA_DATA_DB_ID },
679 { OperationObject::ALL_DEVICE, "" },
680 { OperationObject::ACTIVE_DEVICE, "" },
681 { OperationObject::ASSETMAP, "" },
682 { OperationObject::SMART_ABLUM_ASSETS, "" },
683 { OperationObject::BUNDLE_PERMISSION, "" },
684 };
685
686 MediaLibraryCommand cmd(uri, OperationType::QUERY);
687 // MEDIALIBRARY_TABLE just for RdbPredicates
688 NativeRdb::RdbPredicates rdbPredicate = RdbDataShareAdapter::RdbUtils::ToPredicates(predicates,
689 MEDIALIBRARY_TABLE);
690 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
691 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
692 cmd.GetAbsRdbPredicates()->SetOrder(rdbPredicate.GetOrder());
693
694 shared_ptr<AbsSharedResultSet> queryResultSet;
695 OperationObject oprnObject = cmd.GetOprnObject();
696 auto it = queryConditionMap.find(oprnObject);
697 if (it != queryConditionMap.end()) {
698 queryResultSet = MediaLibraryObjectUtils::QueryWithCondition(cmd, columns, it->second);
699 } else if (oprnObject == OperationObject::FILESYSTEM_ALBUM || oprnObject == OperationObject::MEDIA_VOLUME) {
700 queryResultSet = MediaLibraryAlbumOperations::QueryAlbumOperation(cmd, columns);
701 } else {
702 tracer.Start("QueryFile");
703 queryResultSet = MediaLibraryFileOperations::QueryFileOperation(cmd, columns);
704 }
705 CHECK_AND_RETURN_RET_LOG(queryResultSet != nullptr, nullptr, "Query functionality failed");
706 return queryResultSet;
707 }
708
QuerySync(const std::string & networkId,const std::string & tableName)709 bool MediaLibraryDataManager::QuerySync(const std::string &networkId, const std::string &tableName)
710 {
711 if (networkId.empty() || tableName.empty()) {
712 return false;
713 }
714
715 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
716 auto &deviceManager = OHOS::DistributedHardware::DeviceManager::GetInstance();
717 auto ret = deviceManager.GetLocalDeviceInfo(bundleName_, deviceInfo);
718 if (ret != ERR_OK) {
719 MEDIA_ERR_LOG("MediaLibraryDataManager QuerySync Failed to get local device info.");
720 return false;
721 }
722
723 if (networkId == std::string(deviceInfo.networkId)) {
724 return true;
725 }
726
727 int32_t syncStatus = DEVICE_SYNCSTATUSING;
728 auto result = MediaLibraryDevice::GetInstance()->GetDevicieSyncStatus(networkId, syncStatus);
729 if (result && syncStatus == DEVICE_SYNCSTATUS_COMPLETE) {
730 return true;
731 }
732
733 std::vector<std::string> devices = { networkId };
734 return MediaLibrarySyncTable::SyncPullTable(rdbStore_, bundleName_, tableName, devices);
735 }
736
OpenFile(const Uri & uri,const std::string & mode)737 int32_t MediaLibraryDataManager::OpenFile(const Uri &uri, const std::string &mode)
738 {
739 MediaLibraryCommand cmd(uri, OperationType::OPEN);
740 return MediaLibraryObjectUtils::OpenFile(cmd, mode);
741 }
742
CheckFileNameValid(const DataShareValuesBucket & value)743 bool MediaLibraryDataManager::CheckFileNameValid(const DataShareValuesBucket &value)
744 {
745 bool isValid = false;
746 std::string displayName = value.Get(MEDIA_DATA_DB_NAME, isValid);
747 if (!isValid) {
748 return false;
749 }
750
751 if (displayName.empty()) {
752 return false;
753 }
754
755 return true;
756 }
757
NotifyChange(const Uri & uri)758 void MediaLibraryDataManager::NotifyChange(const Uri &uri)
759 {
760 std::shared_lock<std::shared_mutex> sharedLock(mgrSharedMutex_);
761 if (extension_ != nullptr) {
762 extension_->NotifyChange(uri);
763 }
764 }
765
InitialiseThumbnailService(const std::shared_ptr<OHOS::AbilityRuntime::Context> & extensionContext)766 void MediaLibraryDataManager::InitialiseThumbnailService(
767 const std::shared_ptr<OHOS::AbilityRuntime::Context> &extensionContext)
768 {
769 if (thumbnailService_ != nullptr) {
770 return;
771 }
772 thumbnailService_ = ThumbnailService::GetInstance();
773 if (thumbnailService_ == nullptr) {
774 MEDIA_INFO_LOG("MediaLibraryDataManager::InitialiseThumbnailService failed");
775 }
776 thumbnailService_->Init(rdbStore_, kvStorePtr_, extensionContext);
777 }
778
OnScanFinished(const int32_t status,const std::string & uri,const std::string & path)779 int32_t ScanFileCallback::OnScanFinished(const int32_t status, const std::string &uri, const std::string &path)
780 {
781 auto instance = MediaLibraryDataManager::GetInstance();
782 if (instance != nullptr) {
783 instance->CreateThumbnailAsync(uri);
784 }
785 return E_OK;
786 };
787 } // namespace Media
788 } // namespace OHOS
789