1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define MLOG_TAG "MediaAssetsService"
17
18 #include "media_assets_service.h"
19
20 #include <string>
21
22 #include "media_assets_rdb_operations.h"
23 #include "media_log.h"
24 #include "medialibrary_errno.h"
25 #include "medialibrary_bundle_manager.h"
26 #include "medialibrary_facard_operations.h"
27 #include "media_facard_photos_column.h"
28 #include "commit_edited_asset_dto.h"
29 #include "medialibrary_async_worker.h"
30 #include "medialibrary_vision_operations.h"
31 #include "medialibrary_rdb_utils.h"
32 #include "media_analysis_helper.h"
33 #include "media_file_uri.h"
34 #include "media_file_utils.h"
35 #include "media_visit_count_manager.h"
36 #include "medialibrary_tracer.h"
37 #include "photo_album_column.h"
38 #include "result_set_utils.h"
39 #include "dfx_manager.h"
40 #include "multistages_capture_request_task_manager.h"
41 #include "multistages_capture_manager.h"
42 #include "enhancement_manager.h"
43 #include "story_album_column.h"
44 #include "medialibrary_unistore_manager.h"
45 #include "medialibrary_photo_operations.h"
46 #include "permission_utils.h"
47 #include "medialibrary_notify.h"
48 #include "medialibrary_command.h"
49 #include "uri.h"
50 #include "medialibrary_album_fusion_utils.h"
51 #include "medialibrary_album_operations.h"
52 #include "enhancement_manager.h"
53 #include "rdb_utils.h"
54 #include "location_column.h"
55 #include "vision_column.h"
56 #include "vision_aesthetics_score_column.h"
57 #include "vision_composition_column.h"
58 #include "vision_face_tag_column.h"
59 #include "vision_head_column.h"
60 #include "vision_image_face_column.h"
61 #include "vision_label_column.h"
62 #include "vision_object_column.h"
63 #include "vision_ocr_column.h"
64 #include "vision_pose_column.h"
65 #include "vision_recommendation_column.h"
66 #include "vision_saliency_detect_column.h"
67 #include "vision_segmentation_column.h"
68 #include "vision_total_column.h"
69 #include "vision_video_label_column.h"
70 #include "vision_multi_crop_column.h"
71 #include "medialibrary_data_manager.h"
72 #include "media_app_uri_permission_column.h"
73 #include "media_app_uri_sensitive_column.h"
74 #include "duplicate_photo_operation.h"
75 #include "medialibrary_search_operations.h"
76 #include "medialibrary_common_utils.h"
77 #include "photo_map_column.h"
78 #include "album_operation_uri.h"
79 #include "medialibrary_business_code.h"
80 #include "rdb_utils.h"
81 #include "datashare_result_set.h"
82 #include "query_result_vo.h"
83 #include "user_photography_info_column.h"
84 #include "story_album_column.h"
85 #include "userfile_manager_types.h"
86 #include "story_cover_info_column.h"
87 #include "story_play_info_column.h"
88 #include "vision_column_comm.h"
89 #include "datashare_predicates.h"
90 #include "medialibrary_file_operations.h"
91 #include "close_asset_vo.h"
92 #include "medialibrary_db_const.h"
93 #include "medialibrary_object_utils.h"
94 #include "media_column.h"
95 #include "media_old_photos_column.h"
96 #include "cloud_media_asset_manager.h"
97
98 using namespace std;
99 using namespace OHOS::RdbDataShareAdapter;
100
101 namespace OHOS::Media {
102
103 const int32_t YES = 1;
104 const int32_t NO = 0;
105 const std::string SET_LOCATION_KEY = "set_location";
106 const std::string SET_LOCATION_VALUE = "1";
107 const std::string COLUMN_FILE_ID = "file_id";
108 const std::string COLUMN_DATA = "data";
109 const std::string COLUMN_OLD_FILE_ID = "old_file_id";
110 const std::string COLUMN_OLD_DATA = "old_data";
111 const std::string COLUMN_DISPLAY_NAME = "display_name";
112 constexpr int32_t HIGH_QUALITY_IMAGE = 0;
113
UpdateVisionTableForEdit(AsyncTaskData * taskData)114 static void UpdateVisionTableForEdit(AsyncTaskData *taskData)
115 {
116 CHECK_AND_RETURN_LOG(taskData != nullptr, "taskData is nullptr");
117 UpdateVisionAsyncTaskData* data = static_cast<UpdateVisionAsyncTaskData*>(taskData);
118 CHECK_AND_RETURN_LOG(data != nullptr, "UpdateVisionAsyncTaskData is nullptr");
119 string fileId = to_string(data->fileId_);
120 MediaAssetsRdbOperations::DeleteFromVisionTables(fileId);
121 }
122
GetInstance()123 MediaAssetsService &MediaAssetsService::GetInstance()
124 {
125 static MediaAssetsService service;
126 return service;
127 }
128
RemoveFormInfo(const string & formId)129 int32_t MediaAssetsService::RemoveFormInfo(const string& formId)
130 {
131 MEDIA_INFO_LOG("MediaAssetsService::RemoveFormInfo, formId:%{public}s", formId.c_str());
132 int32_t deleteRows = this->rdbOperation_.RemoveFormInfo(formId);
133 CHECK_AND_RETURN_RET_LOG(deleteRows > 0, E_ERR, "Failed to remove form info");
134 return deleteRows;
135 }
136
RemoveGalleryFormInfo(const string & formId)137 int32_t MediaAssetsService::RemoveGalleryFormInfo(const string& formId)
138 {
139 MEDIA_INFO_LOG("MediaAssetsService::RemoveGalleryFormInfo, formId:%{public}s", formId.c_str());
140 return this->rdbOperation_.RemoveGalleryFormInfo(formId);
141 }
142
SaveFormInfo(const FormInfoDto & formInfoDto)143 int32_t MediaAssetsService::SaveFormInfo(const FormInfoDto& formInfoDto)
144 {
145 string formId = formInfoDto.formIds.front();
146 string fileUri = formInfoDto.fileUris.front();
147 return this->rdbOperation_.SaveFormInfo(formId, fileUri);
148 }
149
SaveGalleryFormInfo(const FormInfoDto & formInfoDto)150 int32_t MediaAssetsService::SaveGalleryFormInfo(const FormInfoDto& formInfoDto)
151 {
152 return this->rdbOperation_.SaveGalleryFormInfo(formInfoDto.formIds, formInfoDto.fileUris);
153 }
154
CommitEditedAsset(const CommitEditedAssetDto & commitEditedAssetDto)155 int32_t MediaAssetsService::CommitEditedAsset(const CommitEditedAssetDto& commitEditedAssetDto)
156 {
157 int32_t errCode = this->rdbOperation_.CommitEditInsert(commitEditedAssetDto.editData,
158 commitEditedAssetDto.fileId);
159 CHECK_AND_RETURN_RET(errCode == E_SUCCESS, errCode);
160 shared_ptr<MediaLibraryAsyncWorker> asyncWorker = MediaLibraryAsyncWorker::GetInstance();
161 CHECK_AND_RETURN_RET_LOG(asyncWorker != nullptr, E_ERR, "Can not get asyncWorker");
162 UpdateVisionAsyncTaskData* taskData =
163 new (std::nothrow) UpdateVisionAsyncTaskData(commitEditedAssetDto.fileId);
164 CHECK_AND_RETURN_RET_LOG(taskData != nullptr, E_ERR, "Failed to new taskData");
165 shared_ptr<MediaLibraryAsyncTask> updateAsyncTask =
166 make_shared<MediaLibraryAsyncTask>(UpdateVisionTableForEdit, taskData);
167 CHECK_AND_PRINT_LOG(updateAsyncTask != nullptr, "UpdateAnalysisDataForEdit fail");
168 asyncWorker->AddTask(updateAsyncTask, true);
169 return errCode;
170 }
171
TrashPhotos(const std::vector<std::string> & uris)172 int32_t MediaAssetsService::TrashPhotos(const std::vector<std::string> &uris)
173 {
174 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::TRASH_PHOTO, MediaLibraryApi::API_10);
175 DataShare::DataSharePredicates predicates;
176 predicates.In(PhotoColumn::MEDIA_ID, uris);
177 cmd.SetDataSharePred(predicates);
178 NativeRdb::ValuesBucket values;
179 values.Put(MediaColumn::MEDIA_DATE_TRASHED, MediaFileUtils::UTCTimeSeconds());
180 cmd.SetValueBucket(values);
181 return MediaLibraryPhotoOperations::TrashPhotos(cmd);
182 }
183
DeletePhotos(const std::vector<std::string> & uris)184 int32_t MediaAssetsService::DeletePhotos(const std::vector<std::string> &uris)
185 {
186 DataShare::DataSharePredicates predicates;
187 predicates.In(MediaColumn::MEDIA_ID, uris);
188 return MediaLibraryAlbumOperations::DeletePhotoAssets(predicates, false, false);
189 }
190
DeletePhotosCompleted(const std::vector<std::string> & fileIds)191 int32_t MediaAssetsService::DeletePhotosCompleted(const std::vector<std::string> &fileIds)
192 {
193 DataShare::DataSharePredicates predicates;
194 predicates.In(PhotoColumn::MEDIA_ID, fileIds);
195 return MediaLibraryAlbumOperations::DeletePhotoAssetsCompleted(predicates, false);
196 }
197
GetLocalDeviceName()198 static std::string GetLocalDeviceName()
199 {
200 #ifdef DISTRIBUTED
201 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
202 auto &deviceManager = OHOS::DistributedHardware::DeviceManager::GetInstance();
203 int32_t ret = deviceManager.GetLocalDeviceInfo(BUNDLE_NAME, deviceInfo);
204 if (ret == 0) {
205 return deviceInfo.deviceName;
206 }
207 MEDIA_ERR_LOG("GetLocalDeviceInfo ret = %{public}d", ret);
208 #endif
209 return "";
210 }
211
GetClientBundleName()212 static std::string GetClientBundleName()
213 {
214 string bundleName = MediaLibraryBundleManager::GetInstance()->GetClientBundleName();
215 if (bundleName.empty()) {
216 MEDIA_ERR_LOG("GetClientBundleName failed");
217 }
218 return bundleName;
219 }
220
AssetChangeSetFavorite(const int32_t fileId,const bool favorite)221 int32_t MediaAssetsService::AssetChangeSetFavorite(const int32_t fileId, const bool favorite)
222 {
223 DataShare::DataSharePredicates predicate;
224 predicate.EqualTo(PhotoColumn::MEDIA_ID, std::to_string(fileId));
225
226 NativeRdb::ValuesBucket values;
227 values.PutInt(PhotoColumn::MEDIA_IS_FAV, favorite ? YES : NO);
228
229 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
230
231 cmd.SetValueBucket(values);
232 cmd.SetDataSharePred(predicate);
233 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
234 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
235 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
236 return MediaLibraryPhotoOperations::Update(cmd);
237 }
238
AssetChangeSetHidden(const std::string & uri,const bool hidden)239 int32_t MediaAssetsService::AssetChangeSetHidden(const std::string &uri, const bool hidden)
240 {
241 DataShare::DataSharePredicates predicate;
242 vector<string> uris{uri};
243 predicate.In(PhotoColumn::MEDIA_ID, uris);
244
245 NativeRdb::ValuesBucket values;
246 values.PutInt(PhotoColumn::MEDIA_HIDDEN, hidden ? YES : NO);
247
248 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::HIDE, MediaLibraryApi::API_10);
249
250 cmd.SetValueBucket(values);
251 cmd.SetDataSharePred(predicate);
252 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
253 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
254 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
255 return MediaLibraryPhotoOperations::Update(cmd);
256 }
257
AssetChangeSetUserComment(const int32_t fileId,const std::string & userComment)258 int32_t MediaAssetsService::AssetChangeSetUserComment(const int32_t fileId, const std::string &userComment)
259 {
260 DataShare::DataSharePredicates predicate;
261 predicate.EqualTo(PhotoColumn::MEDIA_ID, fileId);
262
263 NativeRdb::ValuesBucket values;
264 values.Put(PhotoColumn::PHOTO_USER_COMMENT, userComment);
265
266 MediaLibraryCommand cmd(
267 OperationObject::FILESYSTEM_PHOTO, OperationType::SET_USER_COMMENT, MediaLibraryApi::API_10);
268
269 cmd.SetValueBucket(values);
270 cmd.SetDataSharePred(predicate);
271 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
272 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
273 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
274 return MediaLibraryPhotoOperations::Update(cmd);
275 }
276
AssetChangeSetLocation(const SetLocationDto & dto)277 int32_t MediaAssetsService::AssetChangeSetLocation(const SetLocationDto &dto)
278 {
279 NativeRdb::ValuesBucket values;
280 values.Put(PhotoColumn::MEDIA_ID, dto.fileId);
281 values.Put(PhotoColumn::MEDIA_FILE_PATH, dto.path);
282 values.Put(PhotoColumn::PHOTO_LATITUDE, dto.latitude);
283 values.Put(PhotoColumn::PHOTO_LONGITUDE, dto.longitude);
284 MultiStagesPhotoCaptureManager::UpdateLocation(values, false);
285 return E_OK;
286 }
287
AssetChangeSetTitle(const int32_t fileId,const std::string & title)288 int32_t MediaAssetsService::AssetChangeSetTitle(const int32_t fileId, const std::string &title)
289 {
290 DataShare::DataSharePredicates predicate;
291 predicate.EqualTo(PhotoColumn::MEDIA_ID, fileId);
292
293 NativeRdb::ValuesBucket values;
294 values.Put(PhotoColumn::MEDIA_TITLE, title);
295
296 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
297
298 cmd.SetValueBucket(values);
299 cmd.SetDataSharePred(predicate);
300 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
301 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
302 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
303 return MediaLibraryPhotoOperations::Update(cmd);
304 }
305
AssetChangeSetEditData(const NativeRdb::ValuesBucket & values)306 int32_t MediaAssetsService::AssetChangeSetEditData(const NativeRdb::ValuesBucket &values)
307 {
308 MediaLibraryCommand cmd(
309 OperationObject::FILESYSTEM_PHOTO, OperationType::ADD_FILTERS, values, MediaLibraryApi::API_10);
310
311 cmd.SetDeviceName(GetLocalDeviceName());
312 cmd.SetBundleName(GetClientBundleName());
313 return MediaLibraryPhotoOperations::AddFilters(cmd);
314 }
315
AssetChangeSubmitCache(SubmitCacheDto & dto)316 int32_t MediaAssetsService::AssetChangeSubmitCache(SubmitCacheDto &dto)
317 {
318 MEDIA_INFO_LOG("SubmitCache isWriteGpsAdvanced: %{public}d", dto.isWriteGpsAdvanced);
319
320 MediaLibraryCommand cmd(
321 OperationObject::FILESYSTEM_PHOTO, OperationType::SUBMIT_CACHE, dto.values, MediaLibraryApi::API_10);
322 if (dto.isWriteGpsAdvanced) {
323 cmd.SetApiParam(SET_LOCATION_KEY, SET_LOCATION_VALUE);
324 }
325
326 cmd.SetDeviceName(GetLocalDeviceName());
327 cmd.SetBundleName(GetClientBundleName());
328 int32_t ret = MediaLibraryPhotoOperations::SubmitCache(cmd);
329 CHECK_AND_RETURN_RET_LOG(ret >= 0, ret, "MediaLibraryPhotoOperations::SubmitCache failed");
330 dto.fileId = ret;
331 dto.outUri = cmd.GetResult();
332 return E_OK;
333 }
334
AssetChangeCreateAsset(AssetChangeCreateAssetDto & dto)335 int32_t MediaAssetsService::AssetChangeCreateAsset(AssetChangeCreateAssetDto &dto)
336 {
337 MediaLibraryCommand cmd(
338 OperationObject::FILESYSTEM_PHOTO, OperationType::CREATE, dto.values, MediaLibraryApi::API_10);
339
340 cmd.SetDeviceName(GetLocalDeviceName());
341 cmd.SetBundleName(GetClientBundleName());
342 int32_t ret = MediaLibraryPhotoOperations::Create(cmd);
343 CHECK_AND_RETURN_RET_LOG(ret > 0, ret, "MediaLibraryPhotoOperations::Create failed");
344 dto.fileId = ret;
345 dto.outUri = cmd.GetResult();
346 return E_OK;
347 }
348
AssetChangeAddImage(AddImageDto & dto)349 int32_t MediaAssetsService::AssetChangeAddImage(AddImageDto &dto)
350 {
351 DataShare::DataSharePredicates predicates;
352 predicates.SetWhereClause(PhotoColumn::MEDIA_ID + " = ? ");
353 predicates.SetWhereArgs({to_string(dto.fileId)});
354
355 NativeRdb::ValuesBucket values;
356 values.Put(PhotoColumn::MEDIA_ID, dto.fileId);
357 values.Put(PhotoColumn::PHOTO_ID, dto.photoId);
358 values.Put(PhotoColumn::PHOTO_DEFERRED_PROC_TYPE, dto.deferredProcType);
359
360 MediaLibraryCommand cmd(
361 OperationObject::PAH_MULTISTAGES_CAPTURE, OperationType::ADD_IMAGE, MediaLibraryApi::API_10);
362
363 cmd.SetValueBucket(values);
364 cmd.SetDataSharePred(predicates);
365 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, cmd.GetTableName());
366 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
367 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
368 MultiStagesPhotoCaptureManager::GetInstance().AddImage(cmd);
369 return E_OK;
370 }
371
SetCameraShotKey(const int32_t fileId,const std::string & cameraShotKey)372 int32_t MediaAssetsService::SetCameraShotKey(const int32_t fileId, const std::string &cameraShotKey)
373 {
374 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
375
376 DataShare::DataSharePredicates predicates;
377 predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
378
379 NativeRdb::ValuesBucket values;
380 values.Put(PhotoColumn::CAMERA_SHOT_KEY, cameraShotKey);
381
382 cmd.SetValueBucket(values);
383 cmd.SetDataSharePred(predicates);
384 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, cmd.GetTableName());
385 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
386 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
387 return MediaLibraryPhotoOperations::UpdateFileAsset(cmd);
388 }
389
SaveCameraPhoto(const SaveCameraPhotoDto & dto)390 int32_t MediaAssetsService::SaveCameraPhoto(const SaveCameraPhotoDto &dto)
391 {
392 MediaLibraryCommand cmd(
393 OperationObject::FILESYSTEM_PHOTO, OperationType::SAVE_CAMERA_PHOTO, MediaLibraryApi::API_10);
394
395 if (dto.discardHighQualityPhoto) {
396 string photoId = MultiStagesCaptureRequestTaskManager::GetProcessingPhotoId(dto.fileId);
397 MEDIA_INFO_LOG("fileId: %{public}d, photoId: %{public}s", dto.fileId, photoId.c_str());
398 MultiStagesPhotoCaptureManager::GetInstance().CancelProcessRequest(photoId);
399 MultiStagesPhotoCaptureManager::GetInstance().RemoveImage(photoId, false);
400
401 cmd.SetApiParam(PhotoColumn::PHOTO_DIRTY, to_string(static_cast<int32_t>(DirtyType::TYPE_NEW)));
402 }
403 cmd.SetApiParam(MEDIA_OPERN_KEYWORD, to_string(dto.needScan));
404 cmd.SetApiParam(PhotoColumn::MEDIA_FILE_PATH, dto.path);
405 cmd.SetApiParam(PhotoColumn::MEDIA_ID, to_string(dto.fileId));
406 cmd.SetApiParam(PhotoColumn::PHOTO_SUBTYPE, to_string(dto.photoSubType));
407 cmd.SetApiParam(IMAGE_FILE_TYPE, to_string(dto.imageFileType));
408 NativeRdb::ValuesBucket values;
409 if (dto.supportedWatermarkType != INT32_MIN) {
410 values.Put(PhotoColumn::SUPPORTED_WATERMARK_TYPE, dto.supportedWatermarkType);
411 }
412 if (dto.cameraShotKey != "NotSet") {
413 values.Put(PhotoColumn::CAMERA_SHOT_KEY, dto.cameraShotKey);
414 }
415
416 values.Put(PhotoColumn::PHOTO_IS_TEMP, false);
417 cmd.SetValueBucket(values);
418 return MediaLibraryPhotoOperations::SaveCameraPhoto(cmd);
419 }
420
DiscardCameraPhoto(const int32_t fileId)421 int32_t MediaAssetsService::DiscardCameraPhoto(const int32_t fileId)
422 {
423 MediaLibraryCommand cmd(
424 OperationObject::FILESYSTEM_PHOTO, OperationType::DISCARD_CAMERA_PHOTO, MediaLibraryApi::API_10);
425 cmd.SetApiParam(PhotoColumn::MEDIA_ID, to_string(fileId));
426
427 DataShare::DataSharePredicates predicates;
428 predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
429 predicates.EqualTo(PhotoColumn::PHOTO_IS_TEMP, "1"); // only temp camera photo can be discarded
430 cmd.SetDataSharePred(predicates);
431
432 NativeRdb::ValuesBucket values;
433 values.Put(PhotoColumn::PHOTO_IS_TEMP, true);
434 cmd.SetValueBucket(values);
435 return MediaLibraryPhotoOperations::DiscardCameraPhoto(cmd);
436 }
437
SetEffectMode(const int32_t fileId,const int32_t effectMode)438 int32_t MediaAssetsService::SetEffectMode(const int32_t fileId, const int32_t effectMode)
439 {
440 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
441
442 DataShare::DataSharePredicates predicates;
443 predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
444
445 NativeRdb::ValuesBucket values;
446 values.Put(PhotoColumn::MOVING_PHOTO_EFFECT_MODE, effectMode);
447
448 cmd.SetValueBucket(values);
449 cmd.SetDataSharePred(predicates);
450 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, cmd.GetTableName());
451 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
452 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
453 return MediaLibraryPhotoOperations::UpdateFileAsset(cmd);
454 }
455
SetOrientation(const int32_t fileId,const int32_t orientation)456 int32_t MediaAssetsService::SetOrientation(const int32_t fileId, const int32_t orientation)
457 {
458 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
459
460 DataShare::DataSharePredicates predicates;
461 predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
462
463 NativeRdb::ValuesBucket values;
464 values.Put(PhotoColumn::PHOTO_ORIENTATION, orientation);
465
466 cmd.SetValueBucket(values);
467 cmd.SetDataSharePred(predicates);
468 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, cmd.GetTableName());
469 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
470 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
471 return MediaLibraryPhotoOperations::UpdateFileAsset(cmd);
472 }
473
SetVideoEnhancementAttr(const int32_t fileId,const std::string & photoId,const std::string & path)474 int32_t MediaAssetsService::SetVideoEnhancementAttr(
475 const int32_t fileId, const std::string &photoId, const std::string &path)
476 {
477 MEDIA_DEBUG_LOG("photoId:%{public}s, fileId:%{public}d, path:%{public}s", photoId.c_str(), fileId, path.c_str());
478 MultiStagesVideoCaptureManager::GetInstance().AddVideo(photoId, to_string(fileId), path);
479 return E_OK;
480 }
481
SetSupportedWatermarkType(const int32_t fileId,const int32_t watermarkType)482 int32_t MediaAssetsService::SetSupportedWatermarkType(const int32_t fileId, const int32_t watermarkType)
483 {
484 MediaLibraryCommand cmd(
485 OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE_SUPPORTED_WATERMARK_TYPE, MediaLibraryApi::API_10);
486
487 DataShare::DataSharePredicates predicates;
488 predicates.EqualTo(PhotoColumn::MEDIA_ID, to_string(fileId));
489
490 NativeRdb::ValuesBucket values;
491 values.Put(PhotoColumn::SUPPORTED_WATERMARK_TYPE, watermarkType);
492
493 cmd.SetValueBucket(values);
494 cmd.SetDataSharePred(predicates);
495 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, cmd.GetTableName());
496 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
497 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
498 return MediaLibraryPhotoOperations::UpdateSupportedWatermarkType(cmd);
499 }
500
GrantPhotoUriPermissionInner(const GrantUriPermissionInnerDto & grantUrisPermissionInnerDto)501 int32_t MediaAssetsService::GrantPhotoUriPermissionInner(const GrantUriPermissionInnerDto& grantUrisPermissionInnerDto)
502 {
503 MEDIA_INFO_LOG("enter MediaAssetsService::GrantPhotoUriPermissionInner");
504 auto fileIds_size = grantUrisPermissionInnerDto.fileIds.size();
505 auto uriTypes_size = grantUrisPermissionInnerDto.uriTypes.size();
506 auto permissionTypes_size = grantUrisPermissionInnerDto.permissionTypes.size();
507 bool isValid = ((fileIds_size == uriTypes_size) && (uriTypes_size == permissionTypes_size));
508 CHECK_AND_RETURN_RET_LOG(isValid, E_ERR, "GrantPhotoUriPermissionInner Failed");
509 std::vector<DataShare::DataShareValuesBucket> values;
510 for (size_t i = 0; i < grantUrisPermissionInnerDto.fileIds.size(); i++) {
511 DataShare::DataShareValuesBucket value;
512 if (!grantUrisPermissionInnerDto.appId.empty()) {
513 value.Put(AppUriPermissionColumn::APP_ID, grantUrisPermissionInnerDto.appId);
514 }
515 if (grantUrisPermissionInnerDto.tokenId != -1) {
516 value.Put(AppUriPermissionColumn::TARGET_TOKENID, grantUrisPermissionInnerDto.tokenId);
517 }
518 if (grantUrisPermissionInnerDto.srcTokenId != -1) {
519 value.Put(AppUriPermissionColumn::SOURCE_TOKENID, grantUrisPermissionInnerDto.srcTokenId);
520 }
521 value.Put(AppUriPermissionColumn::FILE_ID, grantUrisPermissionInnerDto.fileIds[i]);
522 value.Put(AppUriPermissionColumn::PERMISSION_TYPE, grantUrisPermissionInnerDto.permissionTypes[i]);
523 value.Put(AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE, grantUrisPermissionInnerDto.hideSensitiveType);
524 value.Put(AppUriPermissionColumn::URI_TYPE, grantUrisPermissionInnerDto.uriTypes[i]);
525 values.push_back(value);
526 }
527 string uri = "datashare:///media/phaccess_granturipermission";
528 Uri createUri(uri);
529 MediaLibraryCommand grantUrisPermCmd(createUri);
530 int32_t errCode = this->rdbOperation_.GrantPhotoUrisPermissionInner(grantUrisPermCmd, values);
531 MEDIA_INFO_LOG("MediaAssetsService::GrantPhotoUriPermissionInner ret:%{public}d", errCode);
532 return errCode;
533 }
534
CheckPhotoUriPermissionInner(CheckUriPermissionInnerDto & checkUriPermissionInnerDto)535 int32_t MediaAssetsService::CheckPhotoUriPermissionInner(CheckUriPermissionInnerDto& checkUriPermissionInnerDto)
536 {
537 MEDIA_INFO_LOG("enter MediaAssetsService::CheckPhotoUriPermissionInner");
538 DataShare::DataSharePredicates predicates;
539 predicates.EqualTo(AppUriPermissionColumn::TARGET_TOKENID, checkUriPermissionInnerDto.targetTokenId);
540 predicates.And()->EqualTo(AppUriPermissionColumn::URI_TYPE, checkUriPermissionInnerDto.uriType);
541 predicates.And()->In(AppUriPermissionColumn::FILE_ID, checkUriPermissionInnerDto.inFileIds);
542 std::vector<std::string> columns = checkUriPermissionInnerDto.columns;
543 string uri = "datashare:///media/phaccess_checkuripermission";
544 Uri checkUri(uri);
545 MediaLibraryCommand grantUrisPermCmd(checkUri);
546 std::vector<std::string> outFileIds;
547 std::vector<int32_t> permissionTypes;
548 int32_t errCode = this->rdbOperation_.CheckPhotoUriPermissionInner(grantUrisPermCmd,
549 predicates, columns, outFileIds, permissionTypes);
550 checkUriPermissionInnerDto.outFileIds = outFileIds;
551 checkUriPermissionInnerDto.permissionTypes = permissionTypes;
552 MEDIA_INFO_LOG("MediaAssetsService::CheckPhotoUriPermissionInner ret:%{public}d", errCode);
553 return errCode;
554 }
555
CancelPhotoUriPermissionInner(const CancelUriPermissionInnerDto & cancelUriPermissionInnerDto)556 int32_t MediaAssetsService::CancelPhotoUriPermissionInner(
557 const CancelUriPermissionInnerDto& cancelUriPermissionInnerDto)
558 {
559 MEDIA_INFO_LOG("enter MediaAssetsService::CancelPhotoUriPermissionInner");
560 auto fileIds_size = cancelUriPermissionInnerDto.fileIds.size();
561 auto uriTypes_size = cancelUriPermissionInnerDto.uriTypes.size();
562 auto permissionTypes_size = cancelUriPermissionInnerDto.permissionTypes.size();
563 bool isValid = ((fileIds_size == uriTypes_size) && (uriTypes_size == permissionTypes_size));
564 CHECK_AND_RETURN_RET_LOG(isValid, E_ERR, "CancelPhotoUriPermissionInner Failed");
565 DataShare::DataSharePredicates predicates;
566 for (size_t i = 0; i < cancelUriPermissionInnerDto.fileIds.size(); i++) {
567 if (i > 0) {
568 predicates.Or();
569 }
570 predicates.BeginWrap();
571 predicates.BeginWrap();
572 predicates.EqualTo(AppUriPermissionColumn::SOURCE_TOKENID, cancelUriPermissionInnerDto.srcTokenId);
573 predicates.Or();
574 predicates.EqualTo(AppUriPermissionColumn::TARGET_TOKENID, cancelUriPermissionInnerDto.srcTokenId);
575 predicates.EndWrap();
576 predicates.EqualTo(AppUriPermissionColumn::FILE_ID, cancelUriPermissionInnerDto.fileIds[i]);
577 predicates.EqualTo(AppUriPermissionColumn::TARGET_TOKENID, cancelUriPermissionInnerDto.targetTokenId);
578 predicates.EqualTo(AppUriPermissionColumn::URI_TYPE, cancelUriPermissionInnerDto.uriTypes[i]);
579 vector<string> permissionTypes = cancelUriPermissionInnerDto.permissionTypes[i];
580 predicates.In(AppUriPermissionColumn::PERMISSION_TYPE, permissionTypes);
581 predicates.EndWrap();
582 }
583 string uri = "datashare:///media/phaccess_granturipermission";
584 Uri deleteUri(uri);
585 MediaLibraryCommand cancelUriPermCmd(deleteUri, Media::OperationType::DELETE);
586
587 int32_t errCode = this->rdbOperation_.CancelPhotoUrisPermissionInner(cancelUriPermCmd, predicates);
588 MEDIA_INFO_LOG("MediaAssetsService::CancelPhotoUriPermissionInner ret:%{public}d", errCode);
589 return errCode;
590 }
591
GetAssets(GetAssetsDto & dto)592 std::shared_ptr<DataShare::DataShareResultSet> MediaAssetsService::GetAssets(GetAssetsDto &dto)
593 {
594 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(dto.columns);
595 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY, MediaLibraryApi::API_10);
596 cmd.SetDataSharePred(dto.predicates);
597 // MEDIALIBRARY_TABLE just for RdbPredicates
598 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(dto.predicates, MEDIALIBRARY_TABLE);
599 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
600 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
601 cmd.GetAbsRdbPredicates()->SetOrder(rdbPredicate.GetOrder());
602
603 auto resultSet = MediaLibraryPhotoOperations::Query(cmd, dto.columns);
604 CHECK_AND_RETURN_RET_LOG(resultSet, nullptr, "Failed to query assets");
605 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
606 return make_shared<DataShare::DataShareResultSet>(resultSetBridge);
607 }
608
GetAllDuplicateAssets(GetAssetsDto & dto)609 std::shared_ptr<DataShare::DataShareResultSet> MediaAssetsService::GetAllDuplicateAssets(GetAssetsDto &dto)
610 {
611 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(dto.columns);
612 RdbPredicates predicates = RdbDataShareAdapter::RdbUtils::ToPredicates(dto.predicates, PhotoColumn::PHOTOS_TABLE);
613 auto resultSet = DuplicatePhotoOperation::GetAllDuplicateAssets(predicates, dto.columns);
614 CHECK_AND_RETURN_RET_LOG(resultSet, nullptr, "Failed to query duplicate assets");
615 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
616 return make_shared<DataShare::DataShareResultSet>(resultSetBridge);
617 }
618
GetDuplicateAssetsToDelete(GetAssetsDto & dto)619 std::shared_ptr<DataShare::DataShareResultSet> MediaAssetsService::GetDuplicateAssetsToDelete(GetAssetsDto &dto)
620 {
621 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(dto.columns);
622 RdbPredicates predicates = RdbDataShareAdapter::RdbUtils::ToPredicates(dto.predicates, PhotoColumn::PHOTOS_TABLE);
623 auto resultSet = DuplicatePhotoOperation::GetDuplicateAssetsToDelete(predicates, dto.columns);
624 CHECK_AND_RETURN_RET_LOG(resultSet, nullptr, "Failed to query duplicate assets for delete");
625 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
626 return make_shared<DataShare::DataShareResultSet>(resultSetBridge);
627 }
628
GetIndexConstructProgress(std::string & indexProgress)629 int32_t MediaAssetsService::GetIndexConstructProgress(std::string &indexProgress)
630 {
631 auto resultSet = MediaLibrarySearchOperations::QueryIndexConstructProgress();
632 CHECK_AND_RETURN_RET_LOG(resultSet, E_FAIL, "Failed to query index construct progress");
633
634 auto errCode = resultSet->GoToFirstRow();
635 if (errCode != NativeRdb::E_OK) {
636 MEDIA_ERR_LOG("ResultSet GotoFirstRow failed, errCode=%{public}d", errCode);
637 return E_FAIL;
638 }
639
640 const vector<string> columns = {PHOTO_COMPLETE_NUM, PHOTO_TOTAL_NUM, VIDEO_COMPLETE_NUM, VIDEO_TOTAL_NUM};
641 int32_t index = 0;
642 string value = "";
643 indexProgress = "{";
644 for (const auto &item : columns) {
645 if (resultSet->GetColumnIndex(item, index) != NativeRdb::E_OK) {
646 MEDIA_ERR_LOG("ResultSet GetColumnIndex failed, progressObject=%{public}s", item.c_str());
647 return E_FAIL;
648 }
649 if (resultSet->GetString(index, value) != NativeRdb::E_OK) {
650 MEDIA_ERR_LOG("ResultSet GetString failed, progressObject=%{public}s", item.c_str());
651 return E_FAIL;
652 }
653 indexProgress += "\"" + item + "\":" + value + ",";
654 }
655 indexProgress = indexProgress.substr(0, indexProgress.length() - 1);
656 indexProgress += "}";
657 MEDIA_DEBUG_LOG("GetProgressStr progress=%{public}s", indexProgress.c_str());
658 return E_OK;
659 }
660
CreateAsset(CreateAssetDto & dto)661 int32_t MediaAssetsService::CreateAsset(CreateAssetDto& dto)
662 {
663 NativeRdb::ValuesBucket assetInfo;
664 assetInfo.PutString(ASSET_EXTENTION, dto.extension);
665 assetInfo.PutInt(MediaColumn::MEDIA_TYPE, dto.mediaType);
666 assetInfo.PutInt(PhotoColumn::PHOTO_SUBTYPE, dto.photoSubtype);
667 if (!dto.title.empty()) {
668 assetInfo.PutString(MediaColumn::MEDIA_TITLE, dto.title);
669 }
670 if (!dto.displayName.empty()) {
671 assetInfo.PutString(MediaColumn::MEDIA_NAME, dto.displayName);
672 }
673 if (!dto.cameraShotKey.empty()) {
674 assetInfo.PutString(PhotoColumn::CAMERA_SHOT_KEY, dto.cameraShotKey);
675 }
676
677 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::CREATE, MediaLibraryApi::API_10);
678
679 cmd.SetValueBucket(assetInfo);
680 cmd.SetDeviceName(GetLocalDeviceName());
681 cmd.SetBundleName(GetClientBundleName());
682 int32_t ret = MediaLibraryPhotoOperations::Create(cmd);
683 CHECK_AND_RETURN_RET_LOG(ret > 0, ret, "MediaLibraryPhotoOperations::Create failed");
684 dto.fileId = ret;
685 dto.outUri = cmd.GetResult();
686 return E_OK;
687 }
688
CreateAssetForApp(CreateAssetDto & dto)689 int32_t MediaAssetsService::CreateAssetForApp(CreateAssetDto& dto)
690 {
691 NativeRdb::ValuesBucket assetInfo;
692 assetInfo.PutString(ASSET_EXTENTION, dto.extension);
693 assetInfo.PutInt(MediaColumn::MEDIA_TYPE, dto.mediaType);
694 assetInfo.PutInt(PhotoColumn::PHOTO_SUBTYPE, dto.photoSubtype);
695 assetInfo.PutString(MEDIA_DATA_DB_OWNER_APPID, dto.appId);
696 assetInfo.PutString(MEDIA_DATA_DB_PACKAGE_NAME, dto.packageName);
697 assetInfo.PutString(MEDIA_DATA_DB_OWNER_PACKAGE, dto.bundleName);
698 if (!dto.title.empty()) {
699 assetInfo.PutString(MediaColumn::MEDIA_TITLE, dto.title);
700 }
701
702 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::CREATE, MediaLibraryApi::API_10);
703
704 cmd.SetValueBucket(assetInfo);
705 cmd.SetApiParam("tokenId", to_string(dto.tokenId));
706 cmd.SetDeviceName(GetLocalDeviceName());
707 cmd.SetBundleName(GetClientBundleName());
708 int32_t ret = MediaLibraryPhotoOperations::Create(cmd);
709 CHECK_AND_RETURN_RET_LOG(ret > 0, ret, "MediaLibraryPhotoOperations::Create failed");
710 dto.fileId = ret;
711 dto.outUri = cmd.GetResult();
712 return E_OK;
713 }
714
CreateAssetForAppWithAlbum(CreateAssetDto & dto)715 int32_t MediaAssetsService::CreateAssetForAppWithAlbum(CreateAssetDto& dto)
716 {
717 if (!this->rdbOperation_.QueryAlbumIdIfExists(dto.ownerAlbumId)) {
718 MEDIA_ERR_LOG("Invalid ownerAlbumId:%{public}s", dto.ownerAlbumId.c_str());
719 return -EINVAL;
720 }
721
722 NativeRdb::ValuesBucket assetInfo;
723 assetInfo.PutString(ASSET_EXTENTION, dto.extension);
724 assetInfo.PutInt(MediaColumn::MEDIA_TYPE, dto.mediaType);
725 assetInfo.PutInt(PhotoColumn::PHOTO_SUBTYPE, dto.photoSubtype);
726 assetInfo.PutString(MEDIA_DATA_DB_OWNER_APPID, dto.appId);
727 assetInfo.PutString(MEDIA_DATA_DB_PACKAGE_NAME, dto.packageName);
728 assetInfo.PutString(MEDIA_DATA_DB_OWNER_PACKAGE, dto.bundleName);
729 assetInfo.PutString(PhotoColumn::PHOTO_OWNER_ALBUM_ID, dto.ownerAlbumId);
730 if (!dto.title.empty()) {
731 assetInfo.PutString(MediaColumn::MEDIA_TITLE, dto.title);
732 }
733
734 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::CREATE, MediaLibraryApi::API_10);
735
736 cmd.SetValueBucket(assetInfo);
737 cmd.SetApiParam("tokenId", to_string(dto.tokenId));
738 cmd.SetDeviceName(GetLocalDeviceName());
739 cmd.SetBundleName(GetClientBundleName());
740 int32_t ret = MediaLibraryPhotoOperations::Create(cmd);
741 CHECK_AND_RETURN_RET_LOG(ret > 0, ret, "MediaLibraryPhotoOperations::Create failed");
742 dto.fileId = ret;
743 dto.outUri = cmd.GetResult();
744 return E_OK;
745 }
746
ConvertToString(const vector<int32_t> & fileIds,std::vector<std::string> & strIds)747 static void ConvertToString(const vector<int32_t> &fileIds, std::vector<std::string> &strIds)
748 {
749 for (int32_t fileId : fileIds) {
750 strIds.push_back(to_string(fileId));
751 }
752 }
753
SetAssetTitle(int32_t fileId,const std::string & title)754 int32_t MediaAssetsService::SetAssetTitle(int32_t fileId, const std::string &title)
755 {
756 NativeRdb::ValuesBucket assetInfo;
757 assetInfo.PutString(PhotoColumn::MEDIA_TITLE, title);
758
759 DataShare::DataSharePredicates predicate;
760 predicate.EqualTo(PhotoColumn::MEDIA_ID, std::to_string(fileId));
761 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE, MediaLibraryApi::API_10);
762
763 cmd.SetValueBucket(assetInfo);
764 cmd.SetDataSharePred(predicate);
765 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
766 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
767 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
768 return MediaLibraryPhotoOperations::Update(cmd);
769 }
770
SetAssetPending(int32_t fileId,int32_t pending)771 int32_t MediaAssetsService::SetAssetPending(int32_t fileId, int32_t pending)
772 {
773 DataShare::DataSharePredicates predicate;
774 predicate.EqualTo(PhotoColumn::MEDIA_ID, std::to_string(fileId));
775
776 NativeRdb::ValuesBucket assetInfo;
777 assetInfo.PutInt(PhotoColumn::MEDIA_TIME_PENDING, pending);
778
779 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::UPDATE_PENDING, MediaLibraryApi::API_10);
780
781 cmd.SetValueBucket(assetInfo);
782 cmd.SetDataSharePred(predicate);
783 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
784 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
785 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
786 return MediaLibraryPhotoOperations::Update(cmd);
787 }
788
SetAssetsFavorite(const std::vector<int32_t> & fileIds,int32_t favorite)789 int32_t MediaAssetsService::SetAssetsFavorite(const std::vector<int32_t> &fileIds, int32_t favorite)
790 {
791 std::vector<std::string> strIds;
792 ConvertToString(fileIds, strIds);
793 std::vector<std::string> uris;
794 this->rdbOperation_.QueryAssetsUri(strIds, uris);
795
796 DataShare::DataSharePredicates predicate;
797 predicate.In(PhotoColumn::MEDIA_ID, uris);
798
799 NativeRdb::ValuesBucket assetInfo;
800 assetInfo.PutInt(PhotoColumn::MEDIA_IS_FAV, favorite);
801
802 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::BATCH_UPDATE_FAV,
803 MediaLibraryApi::API_10);
804
805 cmd.SetValueBucket(assetInfo);
806 cmd.SetDataSharePred(predicate);
807 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
808 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
809 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
810 return MediaLibraryPhotoOperations::Update(cmd);
811 }
812
SetAssetsHiddenStatus(const std::vector<int32_t> & fileIds,int32_t hiddenStatus)813 int32_t MediaAssetsService::SetAssetsHiddenStatus(const std::vector<int32_t> &fileIds, int32_t hiddenStatus)
814 {
815 std::vector<std::string> strIds;
816 ConvertToString(fileIds, strIds);
817 std::vector<std::string> uris;
818 this->rdbOperation_.QueryAssetsUri(strIds, uris);
819
820 DataShare::DataSharePredicates predicate;
821 predicate.In(PhotoColumn::MEDIA_ID, uris);
822
823 NativeRdb::ValuesBucket assetInfo;
824 assetInfo.PutInt(PhotoColumn::MEDIA_HIDDEN, hiddenStatus);
825
826 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::HIDE, MediaLibraryApi::API_10);
827
828 cmd.SetValueBucket(assetInfo);
829 cmd.SetDataSharePred(predicate);
830 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
831 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
832 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
833 return MediaLibraryPhotoOperations::Update(cmd);
834 }
835
SetAssetsRecentShowStatus(const std::vector<int32_t> & fileIds,int32_t recentShowStatus)836 int32_t MediaAssetsService::SetAssetsRecentShowStatus(const std::vector<int32_t> &fileIds, int32_t recentShowStatus)
837 {
838 std::vector<std::string> strIds;
839 ConvertToString(fileIds, strIds);
840 std::vector<std::string> uris;
841 this->rdbOperation_.QueryAssetsUri(strIds, uris);
842
843 DataShare::DataSharePredicates predicate;
844 predicate.In(PhotoColumn::MEDIA_ID, uris);
845
846 NativeRdb::ValuesBucket assetInfo;
847 assetInfo.PutInt(PhotoColumn::PHOTO_IS_RECENT_SHOW, recentShowStatus);
848
849 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::BATCH_UPDATE_RECENT_SHOW,
850 MediaLibraryApi::API_10);
851
852 cmd.SetValueBucket(assetInfo);
853 cmd.SetDataSharePred(predicate);
854 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
855 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
856 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
857 return MediaLibraryPhotoOperations::Update(cmd);
858 }
859
SetAssetsUserComment(const std::vector<int32_t> & fileIds,const std::string & userComment)860 int32_t MediaAssetsService::SetAssetsUserComment(const std::vector<int32_t> &fileIds, const std::string &userComment)
861 {
862 std::vector<std::string> strIds;
863 ConvertToString(fileIds, strIds);
864 std::vector<std::string> uris;
865 this->rdbOperation_.QueryAssetsUri(strIds, uris);
866
867 DataShare::DataSharePredicates predicate;
868 predicate.In(PhotoColumn::MEDIA_ID, uris);
869
870 NativeRdb::ValuesBucket assetInfo;
871 assetInfo.Put(PhotoColumn::PHOTO_USER_COMMENT, userComment);
872
873 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::BATCH_UPDATE_USER_COMMENT,
874 MediaLibraryApi::API_10);
875
876 cmd.SetValueBucket(assetInfo);
877 cmd.SetDataSharePred(predicate);
878 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicate, cmd.GetTableName());
879 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
880 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
881 return MediaLibraryPhotoOperations::Update(cmd);
882 }
883
AddAssetVisitCount(int32_t fileId,int32_t visitType)884 int32_t MediaAssetsService::AddAssetVisitCount(int32_t fileId, int32_t visitType)
885 {
886 MEDIA_INFO_LOG("AddAssetVisitCount fileId:%{public}d, type:%{public}d", fileId, visitType);
887 auto type = static_cast<MediaVisitCountManager::VisitCountType>(visitType);
888 MediaVisitCountManager::AddVisitCount(type, to_string(fileId));
889 return E_OK;
890 }
891
892 struct AnalysisConfig {
893 std::string tableName;
894 std::string totalColumnName;
895 std::vector<std::string> columns;
896 };
897
898 static const std::string FACE_ALBUM_URI = "'" + PhotoAlbumColumns::ANALYSIS_ALBUM_URI_PREFIX + "' || " +
899 ANALYSIS_ALBUM_TABLE + "." + ALBUM_ID + " AS " + ALBUM_URI;
900
901 static const map<int32_t, struct AnalysisConfig> ANALYSIS_CONFIG_MAP = {
902 { ANALYSIS_AESTHETICS_SCORE, { VISION_AESTHETICS_TABLE, AESTHETICS_SCORE, { AESTHETICS_SCORE, PROB } } },
903 { ANALYSIS_LABEL, { VISION_LABEL_TABLE, LABEL, { CATEGORY_ID, SUB_LABEL, PROB, FEATURE,
904 SIM_RESULT, SALIENCY_SUB_PROB } } },
905 { ANALYSIS_VIDEO_LABEL, { VISION_VIDEO_LABEL_TABLE, VIDEO_LABEL, { CATEGORY_ID, CONFIDENCE_PROBABILITY,
906 SUB_CATEGORY, SUB_CONFIDENCE_PROB, SUB_LABEL, SUB_LABEL_PROB, SUB_LABEL_TYPE,
907 TRACKS, VIDEO_PART_FEATURE, FILTER_TAG} } },
908 { ANALYSIS_OCR, { VISION_OCR_TABLE, OCR, { OCR_TEXT, OCR_TEXT_MSG, OCR_WIDTH, OCR_HEIGHT } } },
909 { ANALYSIS_FACE, { VISION_IMAGE_FACE_TABLE, FACE, { FACE_ID, FACE_ALBUM_URI, SCALE_X, SCALE_Y,
910 SCALE_WIDTH, SCALE_HEIGHT, LANDMARKS, PITCH, YAW, ROLL, PROB, TOTAL_FACES, FEATURES, FACE_OCCLUSION,
911 BEAUTY_BOUNDER_X, BEAUTY_BOUNDER_Y, BEAUTY_BOUNDER_WIDTH, BEAUTY_BOUNDER_HEIGHT, FACE_AESTHETICS_SCORE} } },
912 { ANALYSIS_OBJECT, { VISION_OBJECT_TABLE, OBJECT, { OBJECT_ID, OBJECT_LABEL, OBJECT_SCALE_X, OBJECT_SCALE_Y,
913 OBJECT_SCALE_WIDTH, OBJECT_SCALE_HEIGHT, PROB, SCALE_X, SCALE_Y, SCALE_WIDTH, SCALE_HEIGHT } } },
914 { ANALYSIS_RECOMMENDATION, { VISION_RECOMMENDATION_TABLE, RECOMMENDATION, { RECOMMENDATION_ID,
915 RECOMMENDATION_RESOLUTION, RECOMMENDATION_SCALE_X, RECOMMENDATION_SCALE_Y, RECOMMENDATION_SCALE_WIDTH,
916 RECOMMENDATION_SCALE_HEIGHT, SCALE_X, SCALE_Y, SCALE_WIDTH, SCALE_HEIGHT } } },
917 { ANALYSIS_SEGMENTATION, { VISION_SEGMENTATION_TABLE, SEGMENTATION, { SEGMENTATION_AREA, SEGMENTATION_NAME,
918 PROB } } },
919 { ANALYSIS_COMPOSITION, { VISION_COMPOSITION_TABLE, COMPOSITION, { COMPOSITION_ID, COMPOSITION_RESOLUTION,
920 CLOCK_STYLE, CLOCK_LOCATION_X, CLOCK_LOCATION_Y, CLOCK_COLOUR, COMPOSITION_SCALE_X, COMPOSITION_SCALE_Y,
921 COMPOSITION_SCALE_WIDTH, COMPOSITION_SCALE_HEIGHT, SCALE_X, SCALE_Y, SCALE_WIDTH, SCALE_HEIGHT } } },
922 { ANALYSIS_SALIENCY, { VISION_SALIENCY_TABLE, SALIENCY, { SALIENCY_X, SALIENCY_Y } } },
923 { ANALYSIS_DETAIL_ADDRESS, { PhotoColumn::PHOTOS_TABLE, DETAIL_ADDRESS, {
924 PhotoColumn::PHOTOS_TABLE + "." + LATITUDE, PhotoColumn::PHOTOS_TABLE + "." + LONGITUDE, LANGUAGE, COUNTRY,
925 ADMIN_AREA, SUB_ADMIN_AREA, LOCALITY, SUB_LOCALITY, THOROUGHFARE, SUB_THOROUGHFARE, FEATURE_NAME, CITY_NAME,
926 ADDRESS_DESCRIPTION, LOCATION_TYPE, AOI, POI, FIRST_AOI, FIRST_POI, LOCATION_VERSION, FIRST_AOI_CATEGORY,
927 FIRST_POI_CATEGORY} } },
928 { ANALYSIS_HUMAN_FACE_TAG, { VISION_FACE_TAG_TABLE, FACE_TAG, { VISION_FACE_TAG_TABLE + "." + TAG_ID, TAG_NAME,
929 USER_OPERATION, GROUP_TAG, RENAME_OPERATION, CENTER_FEATURES, USER_DISPLAY_LEVEL, TAG_ORDER, IS_ME, COVER_URI,
930 COUNT, PORTRAIT_DATE_MODIFY, ALBUM_TYPE, IS_REMOVED } } },
931 { ANALYSIS_HEAD_POSITION, { VISION_HEAD_TABLE, HEAD, { HEAD_ID, HEAD_LABEL, HEAD_SCALE_X, HEAD_SCALE_Y,
932 HEAD_SCALE_WIDTH, HEAD_SCALE_HEIGHT, PROB, SCALE_X, SCALE_Y, SCALE_WIDTH, SCALE_HEIGHT } } },
933 { ANALYSIS_BONE_POSE, { VISION_POSE_TABLE, POSE, { POSE_ID, POSE_LANDMARKS, POSE_SCALE_X, POSE_SCALE_Y,
934 POSE_SCALE_WIDTH, POSE_SCALE_HEIGHT, PROB, POSE_TYPE, SCALE_X, SCALE_Y, SCALE_WIDTH, SCALE_HEIGHT } } },
935 { ANALYSIS_MULTI_CROP, { VISION_RECOMMENDATION_TABLE, RECOMMENDATION, { MOVEMENT_CROP, MOVEMENT_VERSION } } },
936 };
937
GetAssetAnalysisData(GetAssetAnalysisDataDto & dto)938 int32_t MediaAssetsService::GetAssetAnalysisData(GetAssetAnalysisDataDto &dto)
939 {
940 MEDIA_INFO_LOG("fileId:%{public}d, analysisType:%{public}d, language:%{public}s, analysisTotal:%{public}d",
941 dto.fileId, dto.analysisType, dto.language.c_str(), dto.analysisTotal);
942 auto it = ANALYSIS_CONFIG_MAP.find(dto.analysisType);
943 if (it == ANALYSIS_CONFIG_MAP.end()) {
944 MEDIA_ERR_LOG("Invalid analysisType:%{public}d", dto.analysisType);
945 return -EINVAL;
946 }
947
948 const AnalysisConfig &config = it->second;
949 std::shared_ptr<NativeRdb::ResultSet> resultSet;
950 if (dto.analysisTotal) {
951 NativeRdb::RdbPredicates predicate(VISION_TOTAL_TABLE);
952 predicate.EqualTo(MediaColumn::MEDIA_ID, to_string(dto.fileId));
953 resultSet = MediaLibraryRdbStore::QueryWithFilter(predicate, { config.totalColumnName });
954 } else {
955 NativeRdb::RdbPredicates rdbPredicate(config.tableName);
956 if (dto.analysisType == ANALYSIS_FACE) {
957 string onClause = VISION_IMAGE_FACE_TABLE + "." + TAG_ID + " = " + ANALYSIS_ALBUM_TABLE + "." + TAG_ID +
958 " AND " + ANALYSIS_ALBUM_TABLE + "." + ALBUM_SUBTYPE + " = " + to_string(PhotoAlbumSubType::PORTRAIT);
959 rdbPredicate.LeftOuterJoin(ANALYSIS_ALBUM_TABLE)->On({ onClause });
960 rdbPredicate.EqualTo(MediaColumn::MEDIA_ID, to_string(dto.fileId));
961 resultSet = MediaLibraryRdbStore::QueryWithFilter(rdbPredicate, config.columns);
962 } else if (dto.analysisType == ANALYSIS_HUMAN_FACE_TAG) {
963 string onClause = VISION_IMAGE_FACE_TABLE + "." + TAG_ID + " = " + VISION_FACE_TAG_TABLE + "." + TAG_ID;
964 rdbPredicate.InnerJoin(VISION_IMAGE_FACE_TABLE)->On({ onClause });
965 rdbPredicate.EqualTo(MediaColumn::MEDIA_ID, to_string(dto.fileId));
966 resultSet = MediaLibraryRdbStore::QueryWithFilter(rdbPredicate, config.columns);
967 } else if (dto.analysisType == ANALYSIS_DETAIL_ADDRESS) {
968 string onClause = GEO_KNOWLEDGE_TABLE + "." + LANGUAGE + " = \'" + dto.language + "\' AND " +
969 PhotoColumn::PHOTOS_TABLE + "." + PhotoColumn::MEDIA_ID + " = " + GEO_KNOWLEDGE_TABLE + "." + FILE_ID;
970 rdbPredicate.LeftOuterJoin(GEO_KNOWLEDGE_TABLE)->On({ onClause });
971 rdbPredicate.EqualTo(PhotoColumn::PHOTOS_TABLE + "." + PhotoColumn::MEDIA_ID, to_string(dto.fileId));
972 resultSet = MediaLibraryDataManager::QueryGeo(rdbPredicate, config.columns);
973 } else {
974 rdbPredicate.EqualTo(MediaColumn::MEDIA_ID, to_string(dto.fileId));
975 resultSet = MediaLibraryRdbStore::QueryWithFilter(rdbPredicate, config.columns);
976 }
977 }
978
979 CHECK_AND_RETURN_RET_LOG(resultSet != nullptr, E_HAS_DB_ERROR, "resultSet nullptr");
980 auto bridge = RdbUtils::ToResultSetBridge(resultSet);
981 dto.resultSet = make_shared<DataShare::DataShareResultSet>(bridge);
982 return E_OK;
983 }
984
CloneAsset(const CloneAssetDto & cloneAssetDto)985 int32_t MediaAssetsService::CloneAsset(const CloneAssetDto& cloneAssetDto)
986 {
987 MEDIA_INFO_LOG("MediaAssetsService::CloneAsset, fileId:%{public}d, title:%{public}s",
988 cloneAssetDto.fileId, cloneAssetDto.title.c_str());
989
990 int32_t fileId = cloneAssetDto.fileId;
991 string title = cloneAssetDto.title;
992 return MediaLibraryAlbumFusionUtils::CloneSingleAsset(fileId, title);
993 }
994
ConvertFormat(const ConvertFormatDto & convertFormatDto)995 int32_t MediaAssetsService::ConvertFormat(const ConvertFormatDto& convertFormatDto)
996 {
997 MEDIA_INFO_LOG("ConvertFormat: %{public}s", convertFormatDto.ToString().c_str());
998 int32_t fileId = convertFormatDto.fileId;
999 std::string title = convertFormatDto.title;
1000 std::string extension = convertFormatDto.extension;
1001 return MediaLibraryAlbumFusionUtils::ConvertFormatAsset(fileId, title, extension);
1002 }
1003
RevertToOriginal(const RevertToOriginalDto & revertToOriginalDto)1004 int32_t MediaAssetsService::RevertToOriginal(const RevertToOriginalDto& revertToOriginalDto)
1005 {
1006 int32_t fileId = revertToOriginalDto.fileId;
1007 MEDIA_INFO_LOG("MediaAssetsService::RevertToOriginal, fileId:%{public}d", fileId);
1008
1009 int32_t errCode = this->rdbOperation_.RevertToOrigin(fileId);
1010 if (errCode == E_SUCCESS) {
1011 string fileUri = revertToOriginalDto.fileUri;
1012 Uri uri(fileUri);
1013 MediaLibraryCommand cmdEditCommit(uri);
1014 MediaLibraryVisionOperations::EditCommitOperation(cmdEditCommit);
1015 }
1016 return errCode;
1017 }
1018
SubmitCloudEnhancementTasks(const CloudEnhancementDto & cloudEnhancementDto)1019 int32_t MediaAssetsService::SubmitCloudEnhancementTasks(const CloudEnhancementDto& cloudEnhancementDto)
1020 {
1021 MediaLibraryCommand cmd(PhotoColumn::PHOTOS_TABLE);
1022 DataShare::DataSharePredicates predicate;
1023 predicate.In(MediaColumn::MEDIA_ID, cloudEnhancementDto.fileUris);
1024 cmd.SetDataSharePred(predicate);
1025 #ifdef ABILITY_CLOUD_ENHANCEMENT_SUPPORT
1026 return EnhancementManager::GetInstance().HandleAddOperation(cmd, cloudEnhancementDto.hasCloudWatermark,
1027 cloudEnhancementDto.triggerMode);
1028 #else
1029 MEDIA_ERR_LOG("not supply cloud enhancement service");
1030 return E_ERR;
1031 #endif
1032 }
1033
PrioritizeCloudEnhancementTask(const CloudEnhancementDto & cloudEnhancementDto)1034 int32_t MediaAssetsService::PrioritizeCloudEnhancementTask(const CloudEnhancementDto& cloudEnhancementDto)
1035 {
1036 MediaLibraryCommand cmd(PhotoColumn::PHOTOS_TABLE);
1037 DataShare::DataSharePredicates predicate;
1038 predicate.EqualTo(MediaColumn::MEDIA_ID, cloudEnhancementDto.fileUris.front());
1039 cmd.SetDataSharePred(predicate);
1040 return EnhancementManager::GetInstance().HandlePrioritizeOperation(cmd);
1041 }
1042
CancelCloudEnhancementTasks(const CloudEnhancementDto & cloudEnhancementDto)1043 int32_t MediaAssetsService::CancelCloudEnhancementTasks(const CloudEnhancementDto& cloudEnhancementDto)
1044 {
1045 MediaLibraryCommand cmd(PhotoColumn::PHOTOS_TABLE);
1046 DataShare::DataSharePredicates predicate;
1047 predicate.In(MediaColumn::MEDIA_ID, cloudEnhancementDto.fileUris);
1048 cmd.SetDataSharePred(predicate);
1049 return EnhancementManager::GetInstance().HandleCancelOperation(cmd);
1050 }
1051
CancelAllCloudEnhancementTasks()1052 int32_t MediaAssetsService::CancelAllCloudEnhancementTasks()
1053 {
1054 return EnhancementManager::GetInstance().HandleCancelAllOperation();
1055 }
1056
GrantPhotoUriPermission(const GrantUriPermissionDto & grantUriPermissionDto)1057 int32_t MediaAssetsService::GrantPhotoUriPermission(const GrantUriPermissionDto &grantUriPermissionDto)
1058 {
1059 MEDIA_INFO_LOG("enter MediaAssetsService::GrantPhotoUriPermission");
1060 NativeRdb::ValuesBucket values;
1061 values.PutLong(AppUriPermissionColumn::TARGET_TOKENID, grantUriPermissionDto.tokenId);
1062 values.PutLong(AppUriPermissionColumn::SOURCE_TOKENID, grantUriPermissionDto.srcTokenId);
1063 values.PutInt(AppUriPermissionColumn::FILE_ID, grantUriPermissionDto.fileId);
1064 values.PutInt(AppUriPermissionColumn::PERMISSION_TYPE, grantUriPermissionDto.permissionType);
1065 values.PutInt(AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE, grantUriPermissionDto.hideSensitiveType);
1066 values.PutInt(AppUriPermissionColumn::URI_TYPE, grantUriPermissionDto.uriType);
1067 MediaLibraryCommand grantUriPermCmd(values);
1068 int32_t errCode = this->rdbOperation_.GrantPhotoUriPermission(grantUriPermCmd);
1069 MEDIA_INFO_LOG("MediaAssetsService::GrantPhotoUriPermission ret:%{public}d", errCode);
1070 return errCode;
1071 }
1072
GrantPhotoUrisPermission(const GrantUrisPermissionDto & grantUrisPermissionDto)1073 int32_t MediaAssetsService::GrantPhotoUrisPermission(const GrantUrisPermissionDto &grantUrisPermissionDto)
1074 {
1075 MEDIA_INFO_LOG("enter MediaAssetsService::GrantPhotoUrisPermission");
1076 std::vector<DataShare::DataShareValuesBucket> values;
1077 for (int32_t fileId : grantUrisPermissionDto.fileIds) {
1078 DataShare::DataShareValuesBucket value;
1079 value.Put(AppUriPermissionColumn::TARGET_TOKENID, grantUrisPermissionDto.tokenId);
1080 value.Put(AppUriPermissionColumn::SOURCE_TOKENID, grantUrisPermissionDto.srcTokenId);
1081 value.Put(AppUriPermissionColumn::FILE_ID, fileId);
1082 value.Put(AppUriPermissionColumn::PERMISSION_TYPE, grantUrisPermissionDto.permissionType);
1083 value.Put(AppUriSensitiveColumn::HIDE_SENSITIVE_TYPE, grantUrisPermissionDto.hideSensitiveType);
1084 value.Put(AppUriPermissionColumn::URI_TYPE, grantUrisPermissionDto.uriType);
1085 values.push_back(value);
1086 }
1087 string uri = "datashare:///media/app_uri_permission_operation/create?api_version=10";
1088 Uri createUri(uri);
1089 MediaLibraryCommand grantUrisPermCmd(createUri);
1090 // Use values only
1091 int32_t errCode = this->rdbOperation_.GrantPhotoUrisPermission(grantUrisPermCmd, values);
1092 MEDIA_INFO_LOG("MediaAssetsService::GrantPhotoUrisPermission ret:%{public}d", errCode);
1093 return errCode;
1094 }
1095
CancelPhotoUriPermission(const CancelUriPermissionDto & cancelUriPermissionDto)1096 int32_t MediaAssetsService::CancelPhotoUriPermission(const CancelUriPermissionDto &cancelUriPermissionDto)
1097 {
1098 MEDIA_INFO_LOG("enter MediaAssetsService::CancelPhotoUriPermission");
1099 std::string uriPermissionTabel = "UriPermission";
1100 NativeRdb::RdbPredicates rdbPredicate(uriPermissionTabel);
1101 rdbPredicate.EqualTo(AppUriPermissionColumn::TARGET_TOKENID, cancelUriPermissionDto.tokenId);
1102 rdbPredicate.EqualTo(AppUriPermissionColumn::SOURCE_TOKENID, cancelUriPermissionDto.srcTokenId);
1103 rdbPredicate.EqualTo(AppUriPermissionColumn::FILE_ID, cancelUriPermissionDto.fileId);
1104 rdbPredicate.EqualTo(AppUriPermissionColumn::PERMISSION_TYPE, cancelUriPermissionDto.permissionType);
1105 rdbPredicate.EqualTo(AppUriPermissionColumn::URI_TYPE, cancelUriPermissionDto.uriType);
1106 int32_t errCode = this->rdbOperation_.CancelPhotoUriPermission(rdbPredicate);
1107 MEDIA_INFO_LOG("MediaAssetsService::CancelPhotoUriPermission ret:%{public}d", errCode);
1108 return errCode;
1109 }
1110
StartThumbnailCreationTask(const StartThumbnailCreationTaskDto & startThumbnailCreationTaskDto)1111 int32_t MediaAssetsService::StartThumbnailCreationTask(
1112 const StartThumbnailCreationTaskDto &startThumbnailCreationTaskDto)
1113 {
1114 MEDIA_INFO_LOG(
1115 "enter MediaAssetsService::StartThumbnailCreationTask, %{public}d", startThumbnailCreationTaskDto.requestId);
1116 NativeRdb::RdbPredicates rdbPredicate = OHOS::RdbDataShareAdapter::RdbUtils::ToPredicates(
1117 startThumbnailCreationTaskDto.predicates, PhotoColumn::PHOTOS_TABLE);
1118 int32_t errCode =
1119 this->rdbOperation_.StartThumbnailCreationTask(rdbPredicate, startThumbnailCreationTaskDto.requestId);
1120 MEDIA_INFO_LOG("MediaAssetsService::startThumbnailCreationTaskDto ret:%{public}d", errCode);
1121 return errCode;
1122 }
1123
StopThumbnailCreationTask(const StopThumbnailCreationTaskDto & stopThumbnailCreationTaskDto)1124 int32_t MediaAssetsService::StopThumbnailCreationTask(const StopThumbnailCreationTaskDto &stopThumbnailCreationTaskDto)
1125 {
1126 MEDIA_INFO_LOG("enter MediaAssetsService::StopThumbnailCreationTask");
1127 int32_t errCode = this->rdbOperation_.StopThumbnailCreationTask(stopThumbnailCreationTaskDto.requestId);
1128 MEDIA_INFO_LOG("MediaAssetsService::StopThumbnailCreationTask ret:%{public}d", errCode);
1129 return errCode;
1130 }
1131
RequestContent(const string & mediaId,int32_t & position)1132 int32_t MediaAssetsService::RequestContent(const string& mediaId, int32_t& position)
1133 {
1134 NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1135 predicates.EqualTo(MediaColumn::MEDIA_ID, mediaId);
1136 std::vector<std::string> fetchColumn { PhotoColumn::PHOTO_POSITION };
1137
1138 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, fetchColumn);
1139 if (resultSet == nullptr || resultSet->GoToFirstRow() != E_OK) {
1140 MEDIA_ERR_LOG("query resultSet is nullptr");
1141 return E_ERR;
1142 }
1143
1144 int index;
1145 int err = resultSet->GetColumnIndex(PhotoColumn::PHOTO_POSITION, index);
1146 if (err != E_OK) {
1147 MEDIA_ERR_LOG("Failed to GetColumnIndex");
1148 return E_ERR;
1149 }
1150 resultSet->GetInt(index, position);
1151 return E_OK;
1152 }
1153
GetCloudEnhancementPair(const string & photoUri)1154 shared_ptr<NativeRdb::ResultSet> MediaAssetsService::GetCloudEnhancementPair(const string& photoUri)
1155 {
1156 MediaLibraryCommand cmd(PhotoColumn::PHOTOS_TABLE);
1157 DataShare::DataSharePredicates predicates;
1158 predicates.EqualTo(MediaColumn::MEDIA_ID, photoUri);
1159 cmd.SetDataSharePred(predicates);
1160 return EnhancementManager::GetInstance().HandleGetPairOperation(cmd);
1161 }
1162
QueryCloudEnhancementTaskState(const string & photoUri,QueryCloudEnhancementTaskStateDto & dto)1163 int32_t MediaAssetsService::QueryCloudEnhancementTaskState(const string& photoUri,
1164 QueryCloudEnhancementTaskStateDto& dto)
1165 {
1166 return this->rdbOperation_.QueryEnhancementTaskState(photoUri, dto);
1167 }
1168
SyncCloudEnhancementTaskStatus()1169 int32_t MediaAssetsService::SyncCloudEnhancementTaskStatus()
1170 {
1171 return EnhancementManager::GetInstance().HandleSyncOperation();
1172 }
1173
QueryPhotoStatus(const QueryPhotoReqBody & req,QueryPhotoRespBody & resp)1174 int32_t MediaAssetsService::QueryPhotoStatus(const QueryPhotoReqBody &req, QueryPhotoRespBody &resp)
1175 {
1176 DataShare::DataSharePredicates predicates;
1177 predicates.EqualTo(MediaColumn::MEDIA_ID, req.fileId);
1178 using namespace RdbDataShareAdapter;
1179 RdbPredicates rdbPredicates = RdbUtils::ToPredicates(predicates, PhotoColumn::PHOTOS_TABLE);
1180 std::vector<std::string> columns { PhotoColumn::PHOTO_QUALITY, PhotoColumn::PHOTO_ID };
1181
1182 shared_ptr<NativeRdb::ResultSet> resSet = MediaLibraryRdbStore::QueryWithFilter(rdbPredicates, columns);
1183
1184 auto resultSetBridge = RdbUtils::ToResultSetBridge(resSet);
1185 using namespace DataShare;
1186 auto resultSet = make_shared<DataShareResultSet>(resultSetBridge);
1187
1188 if (resultSet == nullptr || resultSet->GoToFirstRow() != E_OK) {
1189 MEDIA_INFO_LOG("query resultSet is nullptr");
1190 return E_ERR;
1191 }
1192 int indexOfPhotoId = -1;
1193 resultSet->GetColumnIndex(PhotoColumn::PHOTO_ID, indexOfPhotoId);
1194 std::string photoId;
1195 resultSet->GetString(indexOfPhotoId, photoId);
1196 resp.photoId = photoId;
1197
1198 int columnIndexQuality = -1;
1199 resultSet->GetColumnIndex(PhotoColumn::PHOTO_QUALITY, columnIndexQuality);
1200 int currentPhotoQuality = HIGH_QUALITY_IMAGE;
1201 resultSet->GetInt(columnIndexQuality, currentPhotoQuality);
1202 resp.photoQuality = currentPhotoQuality;
1203 return E_SUCCESS;
1204 }
1205
LogMovingPhoto(const AdaptedReqBody & req)1206 int32_t MediaAssetsService::LogMovingPhoto(const AdaptedReqBody &req)
1207 {
1208 string packageName = MediaLibraryBundleManager::GetInstance()->GetClientBundleName();
1209 CHECK_AND_WARN_LOG(!packageName.empty(), "Package name is empty, adapted: %{public}d",
1210 static_cast<int>(req.adapted));
1211 DfxManager::GetInstance()->HandleAdaptationToMovingPhoto(packageName, req.adapted);
1212 return E_SUCCESS;
1213 }
1214
GetResultSetFromDb(const GetResultSetFromDbDto & getResultSetFromDbDto,GetResultSetFromDbRespBody & resp)1215 int32_t MediaAssetsService::GetResultSetFromDb(const GetResultSetFromDbDto& getResultSetFromDbDto,
1216 GetResultSetFromDbRespBody& resp)
1217 {
1218 DataShare::DataSharePredicates predicates;
1219 predicates.EqualTo(getResultSetFromDbDto.columnName, getResultSetFromDbDto.value);
1220 predicates.And()->EqualTo(MEDIA_DATA_DB_IS_TRASH, to_string(NOT_TRASHED));
1221
1222 Uri uri(MEDIALIBRARY_MEDIA_PREFIX);
1223 MediaLibraryCommand cmd(uri);
1224 cmd.SetDataSharePred(predicates);
1225
1226 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, MEDIALIBRARY_TABLE);
1227 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
1228 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
1229 cmd.GetAbsRdbPredicates()->SetOrder(rdbPredicate.GetOrder());
1230 std::vector<std::string> columns = getResultSetFromDbDto.columns;
1231 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(const_cast<vector<string> &>(columns));
1232
1233 shared_ptr<NativeRdb::ResultSet> resultSet = MediaLibraryFileOperations::QueryFileOperation(cmd, columns);
1234 if (resultSet == nullptr) {
1235 MEDIA_ERR_LOG("query resultSet is nullptr");
1236 return E_ERR;
1237 }
1238
1239 auto resultSetBridge = RdbUtils::ToResultSetBridge(resultSet);
1240 resp.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1241 return E_OK;
1242 }
1243
GetResultSetFromPhotosExtend(const string & value,vector<string> & columns,GetResultSetFromPhotosExtendRespBody & resp)1244 int32_t MediaAssetsService::GetResultSetFromPhotosExtend(const string &value, vector<string> &columns,
1245 GetResultSetFromPhotosExtendRespBody& resp)
1246 {
1247 NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1248 string fileId = MediaFileUtils::GetIdFromUri(value);
1249 predicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
1250
1251 shared_ptr<NativeRdb::ResultSet> resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
1252 if (resultSet == nullptr) {
1253 MEDIA_ERR_LOG("query resultSet is nullptr");
1254 return E_ERR;
1255 }
1256
1257 auto resultSetBridge = RdbUtils::ToResultSetBridge(resultSet);
1258 resp.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1259 return E_OK;
1260 }
1261
GetMovingPhotoDateModified(const string & fileId,GetMovingPhotoDateModifiedRespBody & resp)1262 int32_t MediaAssetsService::GetMovingPhotoDateModified(const string &fileId, GetMovingPhotoDateModifiedRespBody& resp)
1263 {
1264 NativeRdb::RdbPredicates predicates(PhotoColumn::PHOTOS_TABLE);
1265 predicates.EqualTo(MediaColumn::MEDIA_ID, fileId);
1266
1267 vector<string> columns = {
1268 MediaColumn::MEDIA_DATE_MODIFIED,
1269 };
1270
1271 auto resultSet = MediaLibraryRdbStore::QueryWithFilter(predicates, columns);
1272 if (resultSet == nullptr || resultSet->GoToNextRow() != NativeRdb::E_OK) {
1273 MEDIA_ERR_LOG("query resultSet is nullptr");
1274 return E_ERR;
1275 }
1276
1277 resp.dateModified = GetInt64Val(MediaColumn::MEDIA_DATE_MODIFIED, resultSet);
1278 return E_OK;
1279 }
1280
CloseAsset(const CloseAssetReqBody & req)1281 int32_t MediaAssetsService::CloseAsset(const CloseAssetReqBody &req)
1282 {
1283 MEDIA_INFO_LOG("enter CloseAsset, req.uri=%{public}s", req.uri.c_str());
1284 ValuesBucket valuesBucket;
1285 valuesBucket.PutString(MEDIA_DATA_DB_URI, req.uri);
1286 MediaLibraryCommand cmd(valuesBucket);
1287 return MediaLibraryObjectUtils::CloseFile(cmd);
1288 }
1289
BuildPredicates(const std::vector<std::string> & queryTabOldPhotosUris,DataShare::DataSharePredicates & predicates)1290 static int BuildPredicates(const std::vector<std::string> &queryTabOldPhotosUris,
1291 DataShare::DataSharePredicates &predicates)
1292 {
1293 const std::string GALLERY_URI_PREFIX = "//media";
1294 const std::string GALLERY_PATH = "/storage/emulated";
1295
1296 vector<string> clauses;
1297 clauses.push_back(PhotoColumn::PHOTOS_TABLE + "." + MediaColumn::MEDIA_ID + " = " +
1298 TabOldPhotosColumn::OLD_PHOTOS_TABLE + "." + TabOldPhotosColumn::MEDIA_ID);
1299 predicates.InnerJoin(PhotoColumn::PHOTOS_TABLE)->On(clauses);
1300
1301 int conditionCount = 0;
1302 for (const auto &uri : queryTabOldPhotosUris) {
1303 if (uri.find(GALLERY_URI_PREFIX) != std::string::npos) {
1304 size_t lastSlashPos = uri.rfind('/');
1305 if (lastSlashPos != std::string::npos && lastSlashPos + 1 < uri.length()) {
1306 std::string idStr = uri.substr(lastSlashPos + 1);
1307 predicates.Or()->EqualTo(TabOldPhotosColumn::MEDIA_OLD_ID, idStr);
1308 conditionCount += 1;
1309 }
1310 } else if (uri.find(GALLERY_PATH) != std::string::npos) {
1311 predicates.Or()->EqualTo(TabOldPhotosColumn::MEDIA_OLD_FILE_PATH, uri);
1312 conditionCount += 1;
1313 } else if (!uri.empty() && std::all_of(uri.begin(), uri.end(), ::isdigit)) {
1314 predicates.Or()->EqualTo(TabOldPhotosColumn::MEDIA_OLD_ID, uri);
1315 conditionCount += 1;
1316 }
1317 }
1318 CHECK_AND_RETURN_RET_LOG(conditionCount != 0, E_FAIL, "Zero uri condition");
1319 return E_OK;
1320 }
1321
GetUrisByOldUrisInner(GetUrisByOldUrisInnerDto & getUrisByOldUrisInnerDto)1322 int32_t MediaAssetsService::GetUrisByOldUrisInner(GetUrisByOldUrisInnerDto& getUrisByOldUrisInnerDto)
1323 {
1324 MEDIA_INFO_LOG("enter MediaAssetsService::GetUrisByOldUrisInner");
1325 DataShare::DataSharePredicates predicates;
1326 int ret = BuildPredicates(getUrisByOldUrisInnerDto.uris, predicates);
1327 CHECK_AND_RETURN_RET_LOG(ret == E_OK, E_ERR, "MediaAssetsService::GetUrisByOldUrisInner build predicates failed");
1328
1329 std::vector<std::string> columns = getUrisByOldUrisInnerDto.columns;
1330
1331 string uri = "datashare:///media/tab_old_photos_operation/query";
1332 Uri getUri(uri);
1333 MediaLibraryCommand getUrisByOldCmd(getUri);
1334 auto resultSet = this->rdbOperation_.GetUrisByOldUrisInner(getUrisByOldCmd,
1335 predicates, columns);
1336
1337 CHECK_AND_RETURN_RET_LOG(resultSet != nullptr, E_ERR,
1338 "MediaAssetsService::GetUrisByOldUrisInner build predicates failed");
1339 while (resultSet->GoToNextRow() == NativeRdb::E_OK) {
1340 getUrisByOldUrisInnerDto.fileIds.emplace_back(GetInt32Val(COLUMN_FILE_ID, resultSet));
1341 getUrisByOldUrisInnerDto.datas.emplace_back(GetStringVal(COLUMN_DATA, resultSet));
1342 getUrisByOldUrisInnerDto.displayNames.emplace_back(GetStringVal(COLUMN_DISPLAY_NAME, resultSet));
1343 getUrisByOldUrisInnerDto.oldFileIds.emplace_back(GetInt32Val(COLUMN_OLD_FILE_ID, resultSet));
1344 getUrisByOldUrisInnerDto.oldDatas.emplace_back(GetStringVal(COLUMN_OLD_DATA, resultSet));
1345 }
1346 return E_OK;
1347 }
1348
Restore(const RestoreDto & dto)1349 int32_t MediaAssetsService::Restore(const RestoreDto &dto)
1350 {
1351 NativeRdb::ValuesBucket values;
1352 values.PutString("albumLpath", dto.albumLpath);
1353 values.PutString("keyPath", dto.keyPath);
1354 values.PutString("isDeduplication", dto.isDeduplication ? "true" : "false");
1355 values.PutString("bundleName", dto.bundleName);
1356 values.PutString("appName", dto.appName);
1357 values.PutString("appId", dto.appId);
1358 MediaLibraryCommand cmd(values);
1359 return MediaLibraryPhotoOperations::ProcessCustomRestore(cmd);
1360 }
1361
StopRestore(const std::string & keyPath)1362 int32_t MediaAssetsService::StopRestore(const std::string &keyPath)
1363 {
1364 NativeRdb::ValuesBucket values;
1365 values.PutString("keyPath", keyPath);
1366 MediaLibraryCommand cmd(values);
1367 return MediaLibraryPhotoOperations::CancelCustomRestore(cmd);
1368 }
1369
StartDownloadCloudMedia(CloudMediaDownloadType downloadType)1370 int32_t MediaAssetsService::StartDownloadCloudMedia(CloudMediaDownloadType downloadType)
1371 {
1372 CloudMediaAssetManager &instance = CloudMediaAssetManager::GetInstance();
1373 return instance.StartDownloadCloudAsset(downloadType);
1374 }
1375
PauseDownloadCloudMedia()1376 int32_t MediaAssetsService::PauseDownloadCloudMedia()
1377 {
1378 CloudMediaAssetManager &instance = CloudMediaAssetManager::GetInstance();
1379 return instance.PauseDownloadCloudAsset(CloudMediaTaskPauseCause::USER_PAUSED);
1380 }
1381
CancelDownloadCloudMedia()1382 int32_t MediaAssetsService::CancelDownloadCloudMedia()
1383 {
1384 CloudMediaAssetManager &instance = CloudMediaAssetManager::GetInstance();
1385 return instance.CancelDownloadCloudAsset();
1386 }
1387
RetainCloudMediaAsset(CloudMediaRetainType retainType)1388 int32_t MediaAssetsService::RetainCloudMediaAsset(CloudMediaRetainType retainType)
1389 {
1390 CloudMediaAssetManager &instance = CloudMediaAssetManager::GetInstance();
1391 return instance.ForceRetainDownloadCloudMedia(retainType);
1392 }
1393
IsEdited(const IsEditedDto & dto,IsEditedRespBody & respBody)1394 int32_t MediaAssetsService::IsEdited(const IsEditedDto &dto, IsEditedRespBody &respBody)
1395 {
1396 DataShare::DataSharePredicates predicates;
1397 vector<string> columns = { PhotoColumn::PHOTO_EDIT_TIME };
1398 predicates.EqualTo(MediaColumn::MEDIA_ID, to_string(dto.fileId));
1399 MediaLibraryCommand cmd(OperationObject::FILESYSTEM_PHOTO, OperationType::QUERY, MediaLibraryApi::API_10);
1400 cmd.SetDataSharePred(predicates);
1401 auto resultSet = MediaLibraryPhotoOperations::Query(cmd, columns);
1402 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
1403 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1404 return E_OK;
1405 }
1406
RequestEditData(const RequestEditDataDto & dto,RequestEditDataRespBody & respBody)1407 int32_t MediaAssetsService::RequestEditData(const RequestEditDataDto &dto, RequestEditDataRespBody &respBody)
1408 {
1409 NativeRdb::RdbPredicates rdbPredicate =
1410 RdbDataShareAdapter::RdbUtils::ToPredicates(dto.predicates, PhotoColumn::PHOTOS_TABLE);
1411
1412 auto resultSet = MediaLibraryRdbStore::QueryEditDataExists(rdbPredicate);
1413 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
1414 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1415 return E_OK;
1416 }
1417
GetEditData(const GetEditDataDto & dto,GetEditDataRespBody & respBody)1418 int32_t MediaAssetsService::GetEditData(const GetEditDataDto &dto, GetEditDataRespBody &respBody)
1419 {
1420 NativeRdb::RdbPredicates rdbPredicate =
1421 RdbDataShareAdapter::RdbUtils::ToPredicates(dto.predicates, PhotoColumn::PHOTOS_TABLE);
1422
1423 auto resultSet = MediaLibraryRdbStore::QueryEditDataExists(rdbPredicate);
1424 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
1425 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1426 return E_OK;
1427 }
1428
GetCloudMediaAssetStatus(string & status)1429 int32_t MediaAssetsService::GetCloudMediaAssetStatus(string &status)
1430 {
1431 CloudMediaAssetManager &instance = CloudMediaAssetManager::GetInstance();
1432 status = instance.GetCloudMediaAssetTaskStatus();
1433 return E_OK;
1434 }
1435
StartAssetAnalysis(const StartAssetAnalysisDto & dto,StartAssetAnalysisRespBody & respBody)1436 int32_t MediaAssetsService::StartAssetAnalysis(const StartAssetAnalysisDto &dto, StartAssetAnalysisRespBody &respBody)
1437 {
1438 Uri uri(dto.uri);
1439 MediaLibraryCommand cmd(uri);
1440 cmd.SetDataSharePred(dto.predicates);
1441 auto resultSet = MediaLibraryVisionOperations::HandleForegroundAnalysisOperation(cmd);
1442 auto resultSetBridge = RdbDataShareAdapter::RdbUtils::ToResultSetBridge(resultSet);
1443 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1444 return E_OK;
1445 }
1446
GetCloudEnhancementPair(const GetCloudEnhancementPairDto & dto,GetCloudEnhancementPairRespBody & respBody)1447 int32_t MediaAssetsService::GetCloudEnhancementPair(
1448 const GetCloudEnhancementPairDto &dto, GetCloudEnhancementPairRespBody &respBody)
1449 {
1450 shared_ptr<NativeRdb::ResultSet> result = MediaAssetsService::GetInstance().GetCloudEnhancementPair(dto.photoUri);
1451 auto resultSetBridge = RdbUtils::ToResultSetBridge(result);
1452 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1453 return E_OK;
1454 }
1455
GetFilePathFromUri(const std::string & virtualId,GetFilePathFromUriRespBody & respBody)1456 int32_t MediaAssetsService::GetFilePathFromUri(const std::string &virtualId, GetFilePathFromUriRespBody &respBody)
1457 {
1458 DataShare::DataSharePredicates predicates;
1459 predicates.EqualTo(MEDIA_DATA_DB_ID, virtualId);
1460 predicates.And()->EqualTo(MEDIA_DATA_DB_IS_TRASH, to_string(NOT_TRASHED));
1461
1462 MediaLibraryCommand cmd(MEDIALIBRARY_TABLE);
1463 cmd.SetDataSharePred(predicates);
1464 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, MEDIALIBRARY_TABLE);
1465 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
1466 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
1467 cmd.GetAbsRdbPredicates()->SetOrder(rdbPredicate.GetOrder());
1468 vector<string> columns = { MEDIA_DATA_DB_FILE_PATH };
1469 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(columns);
1470 shared_ptr<NativeRdb::ResultSet> resultSet = MediaLibraryFileOperations::QueryFileOperation(cmd, columns);
1471 if (resultSet == nullptr) {
1472 MEDIA_ERR_LOG("GetFilePathFromUri query resultSet is nullptr");
1473 return E_ERR;
1474 }
1475
1476 auto resultSetBridge = RdbUtils::ToResultSetBridge(resultSet);
1477 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1478 return E_OK;
1479 }
1480
GetUriFromFilePath(const std::string & tempPath,GetUriFromFilePathRespBody & respBody)1481 int32_t MediaAssetsService::GetUriFromFilePath(const std::string &tempPath, GetUriFromFilePathRespBody &respBody)
1482 {
1483 DataShare::DataSharePredicates predicates;
1484 predicates.EqualTo(MEDIA_DATA_DB_FILE_PATH, tempPath);
1485 predicates.And()->EqualTo(MEDIA_DATA_DB_IS_TRASH, to_string(NOT_TRASHED));
1486
1487 MediaLibraryCommand cmd(MEDIALIBRARY_TABLE);
1488 cmd.SetDataSharePred(predicates);
1489 NativeRdb::RdbPredicates rdbPredicate = RdbUtils::ToPredicates(predicates, MEDIALIBRARY_TABLE);
1490 cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
1491 cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
1492 cmd.GetAbsRdbPredicates()->SetOrder(rdbPredicate.GetOrder());
1493 vector<string> columns = { MEDIA_DATA_DB_ID };
1494 MediaLibraryRdbUtils::AddVirtualColumnsOfDateType(columns);
1495 shared_ptr<NativeRdb::ResultSet> resultSet = MediaLibraryFileOperations::QueryFileOperation(cmd, columns);
1496 if (resultSet == nullptr) {
1497 MEDIA_ERR_LOG("GetUriFromFilePath query resultSet is nullptr");
1498 return E_ERR;
1499 }
1500
1501 auto resultSetBridge = RdbUtils::ToResultSetBridge(resultSet);
1502 respBody.resultSet = make_shared<DataShare::DataShareResultSet>(resultSetBridge);
1503 return E_OK;
1504 }
1505 } // namespace OHOS::Media