1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License"){return 0;}
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 "MediaAssetsControllerService"
17
18 #include "media_assets_controller_service.h"
19 #include "media_assets_service.h"
20 #include "media_log.h"
21 #include "create_asset_vo.h"
22 #include "create_asset_dto.h"
23 #include "form_info_vo.h"
24 #include "form_info_dto.h"
25 #include "modify_assets_vo.h"
26 #include "parameter_utils.h"
27 #include "commit_edited_asset_vo.h"
28 #include "delete_photos_completed_vo.h"
29 #include "asset_change_vo.h"
30 #include "delete_photos_vo.h"
31 #include "trash_photos_vo.h"
32 #include "clone_asset_vo.h"
33 #include "clone_asset_dto.h"
34 #include "revert_to_original_vo.h"
35 #include "revert_to_original_dto.h"
36 #include "media_file_utils.h"
37 #include "cloud_enhancement_vo.h"
38 #include "cloud_enhancement_dto.h"
39 #include "start_download_cloud_media_vo.h"
40 #include "retain_cloud_media_asset_vo.h"
41 #include "grant_photo_uri_permission_vo.h"
42 #include "grant_photo_uris_permission_vo.h"
43 #include "grant_photo_uri_permission_inner_vo.h"
44 #include "cancel_photo_uri_permission_vo.h"
45 #include "cancel_photo_uri_permission_inner_vo.h"
46 #include "check_photo_uri_permission_inner_vo.h"
47 #include "start_thumbnail_creation_task_vo.h"
48 #include "stop_thumbnail_creation_task_vo.h"
49 #include "get_asset_analysis_data_vo.h"
50 #include "get_asset_analysis_data_dto.h"
51 #include "is_edited_vo.h"
52 #include "request_edit_data_vo.h"
53 #include "get_edit_data_vo.h"
54 #include "start_asset_analysis_vo.h"
55 #include "get_cloudmedia_asset_status_vo.h"
56 #include "request_content_vo.h"
57 #include "get_cloud_enhancement_pair_vo.h"
58 #include "query_cloud_enhancement_task_state_vo.h"
59 #include "query_cloud_enhancement_task_state_dto.h"
60 #include "adapted_vo.h"
61 #include "get_photo_index_vo.h"
62 #include "query_photo_vo.h"
63 #include "get_highlight_album_info_vo.h"
64 #include "get_analysis_process_vo.h"
65 #include "get_index_construct_progress_vo.h"
66 #include "medialibrary_rdb_utils.h"
67 #include "permission_common.h"
68 #include "convert_format_vo.h"
69 #include "convert_format_dto.h"
70 #include "add_visit_count_vo.h"
71 #include "get_result_set_from_db_vo.h"
72 #include "get_result_set_from_photos_extend_vo.h"
73 #include "get_moving_photo_date_modified_vo.h"
74 #include "get_uri_from_filepath_vo.h"
75 #include "get_filepath_from_uri_vo.h"
76 #include "get_uris_by_old_uris_inner_vo.h"
77 #include "close_asset_vo.h"
78 #include "stop_restore_vo.h"
79 #include "medialibrary_file_operations.h"
80 #include "dfx_timer.h"
81 #include "dfx_const.h"
82 #include "cloud_media_asset_types.h"
83 #include "is_edited_dto.h"
84 #include "request_edit_data_dto.h"
85 #include "get_edit_data_dto.h"
86 #include "start_asset_analysis_dto.h"
87 #include "get_cloud_enhancement_pair_dto.h"
88 #include "permission_utils.h"
89 #include "media_app_uri_permission_column.h"
90
91 namespace OHOS::Media {
92 using namespace std;
93 static const size_t FACARD_MAX_REGISTER_OBSERVER = 500;
94
95 using SpecialRequestHandle = int32_t (MediaAssetsControllerService::*)(
96 MessageParcel &, MessageParcel &, OHOS::Media::IPC::IPCContext &);
97
98 using RequestHandle = int32_t (MediaAssetsControllerService::*)(MessageParcel &, MessageParcel &);
99
100 const std::map<uint32_t, SpecialRequestHandle> SPECIAL_HANDLERS = {
101 {
102 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GET_ASSETS),
103 &MediaAssetsControllerService::GetAssets
104 },
105 {
106 static_cast<uint32_t>(MediaLibraryBusinessCode::GET_BURST_ASSETS),
107 &MediaAssetsControllerService::GetBurstAssets
108 },
109 };
110
111 const std::map<uint32_t, RequestHandle> HANDLERS = {
112 {
113 static_cast<uint32_t>(MediaLibraryBusinessCode::REMOVE_FORM_INFO),
114 &MediaAssetsControllerService::RemoveFormInfo
115 },
116 {
117 static_cast<uint32_t>(MediaLibraryBusinessCode::REMOVE_GALLERY_FORM_INFO),
118 &MediaAssetsControllerService::RemoveGalleryFormInfo
119 },
120 {
121 static_cast<uint32_t>(MediaLibraryBusinessCode::SAVE_FORM_INFO),
122 &MediaAssetsControllerService::SaveFormInfo
123 },
124 {
125 static_cast<uint32_t>(MediaLibraryBusinessCode::SAVE_GALLERY_FORM_INFO),
126 &MediaAssetsControllerService::SaveGalleryFormInfo
127 },
128 {
129 static_cast<uint32_t>(MediaLibraryBusinessCode::COMMIT_EDITED_ASSET),
130 &MediaAssetsControllerService::CommitEditedAsset
131 },
132 {
133 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYS_TRASH_PHOTOS),
134 &MediaAssetsControllerService::SysTrashPhotos
135 },
136 {
137 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_TRASH_PHOTOS),
138 &MediaAssetsControllerService::TrashPhotos
139 },
140 {
141 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_DELETE_PHOTOS),
142 &MediaAssetsControllerService::DeletePhotos
143 },
144 {
145 static_cast<uint32_t>(MediaLibraryBusinessCode::DELETE_PHOTOS_COMPLETED),
146 &MediaAssetsControllerService::DeletePhotosCompleted
147 },
148 {
149 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_FAVORITE),
150 &MediaAssetsControllerService::AssetChangeSetFavorite
151 },
152 {
153 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_HIDDEN),
154 &MediaAssetsControllerService::AssetChangeSetHidden
155 },
156 {
157 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_USER_COMMENT),
158 &MediaAssetsControllerService::AssetChangeSetUserComment
159 },
160 {
161 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_LOCATION),
162 &MediaAssetsControllerService::AssetChangeSetLocation
163 },
164 {
165 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_TITLE),
166 &MediaAssetsControllerService::AssetChangeSetTitle
167 },
168 {
169 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_EDIT_DATA),
170 &MediaAssetsControllerService::AssetChangeSetEditData
171 },
172 {
173 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SUBMIT_CACHE),
174 &MediaAssetsControllerService::AssetChangeSubmitCache
175 },
176 {
177 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_CREATE_ASSET),
178 &MediaAssetsControllerService::AssetChangeCreateAsset
179 },
180 {
181 static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_ADD_IMAGE),
182 &MediaAssetsControllerService::AssetChangeAddImage
183 },
184 {
185 static_cast<uint32_t>(MediaLibraryBusinessCode::SET_CAMERA_SHOT_KEY),
186 &MediaAssetsControllerService::SetCameraShotKey
187 },
188 {
189 static_cast<uint32_t>(MediaLibraryBusinessCode::SAVE_CAMERA_PHOTO),
190 &MediaAssetsControllerService::SaveCameraPhoto
191 },
192 {
193 static_cast<uint32_t>(MediaLibraryBusinessCode::DISCARD_CAMERA_PHOTO),
194 &MediaAssetsControllerService::DiscardCameraPhoto
195 },
196 {
197 static_cast<uint32_t>(MediaLibraryBusinessCode::SET_EFFECT_MODE),
198 &MediaAssetsControllerService::SetEffectMode
199 },
200 {
201 static_cast<uint32_t>(MediaLibraryBusinessCode::SET_ORIENTATION),
202 &MediaAssetsControllerService::SetOrientation
203 },
204 {
205 static_cast<uint32_t>(MediaLibraryBusinessCode::SET_VIDEO_ENHANCEMENT_ATTR),
206 &MediaAssetsControllerService::SetVideoEnhancementAttr
207 },
208 {
209 static_cast<uint32_t>(MediaLibraryBusinessCode::SET_SUPPORTED_WATERMARK_TYPE),
210 &MediaAssetsControllerService::SetSupportedWatermarkType
211 },
212 {
213 static_cast<uint32_t>(MediaLibraryBusinessCode::FIND_ALL_DUPLICATE_ASSETS),
214 &MediaAssetsControllerService::GetAllDuplicateAssets
215 },
216 {
217 static_cast<uint32_t>(MediaLibraryBusinessCode::FIND_DUPLICATE_ASSETS_TO_DELETE),
218 &MediaAssetsControllerService::GetDuplicateAssetsToDelete
219 },
220 {
221 static_cast<uint32_t>(MediaLibraryBusinessCode::GET_INDEX_CONSTRUCT_PROGRESS),
222 &MediaAssetsControllerService::GetIndexConstructProgress
223 },
224 {
225 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_PUBLIC_CREATE_ASSET),
226 &MediaAssetsControllerService::PublicCreateAsset
227 },
228 {
229 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET),
230 &MediaAssetsControllerService::SystemCreateAsset
231 },
232 {
233 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_PUBLIC_CREATE_ASSET_FOR_APP),
234 &MediaAssetsControllerService::PublicCreateAssetForApp
235 },
236 {
237 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET_FOR_APP),
238 &MediaAssetsControllerService::SystemCreateAssetForApp
239 },
240 {
241 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET_FOR_APP_WITH_MODE),
242 &MediaAssetsControllerService::SystemCreateAssetForApp
243 },
244 {
245 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET_FOR_APP_WITH_ALBUM),
246 &MediaAssetsControllerService::CreateAssetForAppWithAlbum
247 },
248 {
249 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_PUBLIC_SET_TITLE),
250 &MediaAssetsControllerService::SetAssetTitle
251 },
252 {
253 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_SET_PENDING),
254 &MediaAssetsControllerService::SetAssetPending
255 },
256 {
257 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_SET_FAVORITE),
258 &MediaAssetsControllerService::SetAssetsFavorite
259 },
260 {
261 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_SET_USER_COMMENT),
262 &MediaAssetsControllerService::SetAssetsUserComment
263 },
264 {
265 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_BATCH_SET_HIDDEN),
266 &MediaAssetsControllerService::SetAssetsHiddenStatus
267 },
268 {
269 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_BATCH_SET_FAVORITE),
270 &MediaAssetsControllerService::SetAssetsFavorite
271 },
272 {
273 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_BATCH_SET_RECENT_SHOW),
274 &MediaAssetsControllerService::SetAssetsRecentShowStatus
275 },
276 {
277 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_BATCH_SET_USER_COMMENT),
278 &MediaAssetsControllerService::SetAssetsUserComment
279 },
280 {
281 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_ADD_ASSET_VISIT_COUNT),
282 &MediaAssetsControllerService::AddAssetVisitCount
283 },
284 {
285 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CREATE_ASSET),
286 &MediaAssetsControllerService::SystemCreateAsset
287 },
288 {
289 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CANCEL_PHOTO_URI_PERMISSION),
290 &MediaAssetsControllerService::CancelPhotoUriPermissionInner
291 },
292 {
293 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GRANT_PHOTO_URI_PERMISSION),
294 &MediaAssetsControllerService::GrantPhotoUriPermissionInner
295 },
296 {
297 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CHECK_PHOTO_URI_PERMISSION),
298 &MediaAssetsControllerService::CheckUriPermissionInner
299 },
300 {
301 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CHECK_AUDIO_URI_PERMISSION),
302 &MediaAssetsControllerService::CheckUriPermissionInner
303 },
304 {
305 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_URIS_BY_OLD_URIS),
306 &MediaAssetsControllerService::GetUrisByOldUrisInner
307 },
308 {
309 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GET_ASSET_ANALYSIS_DATA),
310 &MediaAssetsControllerService::GetAssetAnalysisData
311 },
312 {
313 static_cast<uint32_t>(MediaLibraryBusinessCode::CLONE_ASSET),
314 &MediaAssetsControllerService::CloneAsset
315 },
316 {
317 static_cast<uint32_t>(MediaLibraryBusinessCode::REVERT_TO_ORIGINAL),
318 &MediaAssetsControllerService::RevertToOriginal
319 },
320 {
321 static_cast<uint32_t>(MediaLibraryBusinessCode::UPDATE_GALLERY_FORM_INFO),
322 &MediaAssetsControllerService::UpdateGalleryFormInfo
323 },
324 {
325 static_cast<uint32_t>(MediaLibraryBusinessCode::SUBMIT_CLOUD_ENHANCEMENT_TASKS),
326 &MediaAssetsControllerService::SubmitCloudEnhancementTasks
327 },
328 {
329 static_cast<uint32_t>(MediaLibraryBusinessCode::PRIORITIZE_CLOUD_ENHANCEMENT_TASK),
330 &MediaAssetsControllerService::PrioritizeCloudEnhancementTask
331 },
332 {
333 static_cast<uint32_t>(MediaLibraryBusinessCode::CANCEL_CLOUD_ENHANCEMENT_TASKS),
334 &MediaAssetsControllerService::CancelCloudEnhancementTasks
335 },
336 {
337 static_cast<uint32_t>(MediaLibraryBusinessCode::CANCEL_ALL_CLOUD_ENHANCEMENT_TASKS),
338 &MediaAssetsControllerService::CancelAllCloudEnhancementTasks
339 },
340 {
341 static_cast<uint32_t>(MediaLibraryBusinessCode::START_DOWNLOAD_CLOUDMEDIA),
342 &MediaAssetsControllerService::StartDownloadCloudMedia
343 },
344 {
345 static_cast<uint32_t>(MediaLibraryBusinessCode::PAUSE_DOWNLOAD_CLOUDMEDIA),
346 &MediaAssetsControllerService::PauseDownloadCloudMedia
347 },
348 {
349 static_cast<uint32_t>(MediaLibraryBusinessCode::CANCEL_DOWNLOAD_CLOUDMEDIA),
350 &MediaAssetsControllerService::CancelDownloadCloudMedia
351 },
352 {
353 static_cast<uint32_t>(MediaLibraryBusinessCode::RETAIN_CLOUDMEDIA_ASSET),
354 &MediaAssetsControllerService::RetainCloudMediaAsset
355 },
356 {
357 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_RETAIN_CLOUDMEDIA_ASSET),
358 &MediaAssetsControllerService::RetainCloudMediaAsset
359 },
360 {
361 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GRANT_PHOTO_URI_PERMISSION),
362 &MediaAssetsControllerService::GrantPhotoUriPermission
363 },
364 {
365 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GRANT_PHOTO_URIS_PERMISSION),
366 &MediaAssetsControllerService::GrantPhotoUrisPermission
367 },
368 {
369 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_CANCEL_PHOTO_URI_PERMISSION),
370 &MediaAssetsControllerService::CancelPhotoUriPermission
371 },
372 {
373 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_START_THUMBNAIL_CREATION_TASK),
374 &MediaAssetsControllerService::StartThumbnailCreationTask
375 },
376 {
377 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_STOP_THUMBNAIL_CREATION_TASK),
378 &MediaAssetsControllerService::StopThumbnailCreationTask
379 },
380 {
381 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_IS_EDITED),
382 &MediaAssetsControllerService::IsEdited
383 },
384 {
385 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_REQUEST_EDIT_DATA),
386 &MediaAssetsControllerService::RequestEditData
387 },
388 {
389 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_GET_EDIT_DATA),
390 &MediaAssetsControllerService::GetEditData
391 },
392 {
393 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_GET_CLOUDMEDIA_ASSET_STATUS),
394 &MediaAssetsControllerService::GetCloudMediaAssetStatus
395 },
396 {
397 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_START_ASSET_ANALYSIS),
398 &MediaAssetsControllerService::StartAssetAnalysis
399 },
400 {
401 static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_REQUEST_CONTENT),
402 &MediaAssetsControllerService::RequestContent
403 },
404 {
405 static_cast<uint32_t>(MediaLibraryBusinessCode::GET_CLOUD_ENHANCEMENT_PAIR),
406 &MediaAssetsControllerService::GetCloudEnhancementPair
407 },
408 {
409 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_CLOUD_ENHANCEMENT_TASK_STATE),
410 &MediaAssetsControllerService::QueryCloudEnhancementTaskState
411 },
412 {
413 static_cast<uint32_t>(MediaLibraryBusinessCode::SYNC_CLOUD_ENHANCEMENT_TASK_STATUS),
414 &MediaAssetsControllerService::SyncCloudEnhancementTaskStatus
415 },
416 {
417 static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_PHOTO_STATUS),
418 &MediaAssetsControllerService::QueryPhotoStatus
419 },
420 {
421 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_QUERY_PHOTO_STATUS),
422 &MediaAssetsControllerService::QueryPhotoStatus
423 },
424 {
425 static_cast<uint32_t>(MediaLibraryBusinessCode::LOG_MOVING_PHOTO),
426 &MediaAssetsControllerService::LogMovingPhoto
427 },
428 {
429 static_cast<uint32_t>(MediaLibraryBusinessCode::CONVERT_FORMAT),
430 &MediaAssetsControllerService::ConvertFormat
431 },
432 {
433 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_RESULT_SET_FROM_DB),
434 &MediaAssetsControllerService::GetResultSetFromDb
435 },
436 {
437 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_RESULT_SET_FROM_DB_EXTEND),
438 &MediaAssetsControllerService::GetResultSetFromDb
439 },
440 {
441 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_RESULT_SET_FROM_PHOTOS),
442 &MediaAssetsControllerService::GetResultSetFromPhotosExtend
443 },
444 {
445 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_RESULT_SET_FROM_PHOTOS_EXTEND),
446 &MediaAssetsControllerService::GetResultSetFromPhotosExtend
447 },
448 {
449 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_MOVING_PHOTO_DATE_MODIFIED),
450 &MediaAssetsControllerService::GetMovingPhotoDateModified
451 },
452 {
453 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_FILEPATH_FROM_URI),
454 &MediaAssetsControllerService::GetFilePathFromUri
455 },
456 {
457 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_URI_FROM_FILEPATH),
458 &MediaAssetsControllerService::GetUriFromFilePath
459 },
460 {
461 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CLOSE_ASSET),
462 &MediaAssetsControllerService::CloseAsset
463 },
464 {
465 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CUSTOM_RESTORE),
466 &MediaAssetsControllerService::Restore
467 },
468 {
469 static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CUSTOM_RESTORE_CANCEL),
470 &MediaAssetsControllerService::StopRestore
471 },
472 };
473
Accept(uint32_t code)474 bool MediaAssetsControllerService::Accept(uint32_t code)
475 {
476 return HANDLERS.find(code) != HANDLERS.end() || SPECIAL_HANDLERS.find(code) != SPECIAL_HANDLERS.end();
477 }
478
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,OHOS::Media::IPC::IPCContext & context)479 int32_t MediaAssetsControllerService::OnRemoteRequest(
480 uint32_t code, MessageParcel &data, MessageParcel &reply, OHOS::Media::IPC::IPCContext &context)
481 {
482 auto handlersIt = HANDLERS.find(code);
483 if (handlersIt != HANDLERS.end()) {
484 return (this->*(handlersIt->second))(data, reply);
485 }
486 auto specialHandlersIt = SPECIAL_HANDLERS.find(code);
487 if (specialHandlersIt != SPECIAL_HANDLERS.end()) {
488 return (this->*(specialHandlersIt->second))(data, reply, context);
489 }
490 return IPC::UserDefineIPC().WriteResponseBody(reply, E_IPC_SEVICE_NOT_FOUND);
491 }
492
RemoveFormInfo(MessageParcel & data,MessageParcel & reply)493 int32_t MediaAssetsControllerService::RemoveFormInfo(MessageParcel &data, MessageParcel &reply)
494 {
495 MEDIA_INFO_LOG("enter RemoveFormInfo");
496 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::REMOVE_FORM_INFO);
497 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
498 DfxTimer dfxTimer(operationCode, timeout, true);
499 FormInfoReqBody reqBody;
500 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
501 if (ret != E_OK) {
502 MEDIA_ERR_LOG("RemoveFormInfo Read Request Error");
503 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
504 }
505 ret = ParameterUtils::CheckFormIds(reqBody.formIds);
506 if (ret == E_OK) {
507 ret = MediaAssetsService::GetInstance().RemoveFormInfo(reqBody.formIds.front());
508 }
509 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
510 }
511
RemoveGalleryFormInfo(MessageParcel & data,MessageParcel & reply)512 int32_t MediaAssetsControllerService::RemoveGalleryFormInfo(MessageParcel &data, MessageParcel &reply)
513 {
514 MEDIA_INFO_LOG("enter RemoveGalleryFormInfo");
515 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::REMOVE_GALLERY_FORM_INFO);
516 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
517 DfxTimer dfxTimer(operationCode, timeout, true);
518 FormInfoReqBody reqBody;
519 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
520 if (ret != E_OK) {
521 MEDIA_ERR_LOG("RemoveFormInfo Read Request Error");
522 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
523 }
524 ret = ParameterUtils::CheckFormIds(reqBody.formIds);
525 if (ret == E_OK) {
526 ret = MediaAssetsService::GetInstance().RemoveGalleryFormInfo(reqBody.formIds.front());
527 }
528 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
529 }
530
SaveFormInfo(MessageParcel & data,MessageParcel & reply)531 int32_t MediaAssetsControllerService::SaveFormInfo(MessageParcel &data, MessageParcel &reply)
532 {
533 MEDIA_INFO_LOG("enter SaveFormInfo");
534 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::SAVE_FORM_INFO);
535 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
536 DfxTimer dfxTimer(operationCode, timeout, true);
537 FormInfoReqBody reqBody;
538 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
539 if (ret != E_OK) {
540 MEDIA_ERR_LOG("SaveFormInfo Read Request Error");
541 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
542 }
543 ret = ParameterUtils::CheckFormIds(reqBody.formIds);
544 FormInfoDto formInfoDto;
545 formInfoDto.formIds = reqBody.formIds;
546 formInfoDto.fileUris = reqBody.fileUris;
547 if (formInfoDto.formIds.empty() || formInfoDto.fileUris.empty()) {
548 MEDIA_ERR_LOG("formIds or fileUris is empty");
549 ret = E_GET_PRAMS_FAIL;
550 }
551 if (ret == E_OK) {
552 ret = MediaAssetsService::GetInstance().SaveFormInfo(formInfoDto);
553 }
554 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
555 }
556
SaveGalleryFormInfo(MessageParcel & data,MessageParcel & reply)557 int32_t MediaAssetsControllerService::SaveGalleryFormInfo(MessageParcel &data, MessageParcel &reply)
558 {
559 MEDIA_INFO_LOG("enter SaveGalleryFormInfo");
560 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::SAVE_GALLERY_FORM_INFO);
561 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
562 DfxTimer dfxTimer(operationCode, timeout, true);
563 FormInfoReqBody reqBody;
564 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
565 if (ret != E_OK) {
566 MEDIA_ERR_LOG("SaveGalleryFormInfo Read Request Error");
567 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
568 }
569 ret = ParameterUtils::CheckFormIds(reqBody.formIds);
570 FormInfoDto formInfoDto;
571 formInfoDto.formIds = reqBody.formIds;
572 formInfoDto.fileUris = reqBody.fileUris;
573 bool cond = (formInfoDto.formIds.size() != formInfoDto.fileUris.size()) || formInfoDto.formIds.empty()
574 || formInfoDto.fileUris.empty();
575 ret = cond ? E_GET_PRAMS_FAIL : ret;
576 CHECK_AND_PRINT_LOG(!cond, "formIds or fileUris is empty or count not equal");
577 if (formInfoDto.fileUris.size() > FACARD_MAX_REGISTER_OBSERVER) {
578 MEDIA_INFO_LOG("registered uri exceeds the maximum limit, uri size:%{public}d",
579 static_cast<int32_t>(formInfoDto.formIds.size()));
580 formInfoDto.formIds = std::vector<std::string>(formInfoDto.formIds.begin(),
581 formInfoDto.formIds.begin() + FACARD_MAX_REGISTER_OBSERVER);
582 formInfoDto.fileUris = std::vector<std::string>(formInfoDto.fileUris.begin(),
583 formInfoDto.fileUris.begin() + FACARD_MAX_REGISTER_OBSERVER);
584 }
585 if (ret == E_OK) {
586 ret = MediaAssetsService::GetInstance().SaveGalleryFormInfo(formInfoDto);
587 }
588 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
589 }
590
CommitEditedAsset(MessageParcel & data,MessageParcel & reply)591 int32_t MediaAssetsControllerService::CommitEditedAsset(MessageParcel &data, MessageParcel &reply)
592 {
593 MEDIA_INFO_LOG("enter CommitEditedAsset");
594 CommitEditedAssetReqBody reqBody;
595 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
596 if (ret != E_OK) {
597 MEDIA_ERR_LOG("CommitEditedAsset Read Request Error");
598 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
599 }
600
601 bool cond = ParameterUtils::CheckEditDataLength(reqBody.editData) && reqBody.fileId > 0;
602 if (!cond) {
603 MEDIA_ERR_LOG("params not valid");
604 ret = E_INVALID_VALUES;
605 }
606
607 CommitEditedAssetDto commitEditedAssetDto;
608 commitEditedAssetDto.editData = reqBody.editData;
609 commitEditedAssetDto.fileId = reqBody.fileId;
610
611 if (ret == E_OK) {
612 ret = MediaAssetsService::GetInstance().CommitEditedAsset(commitEditedAssetDto);
613 }
614 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
615 }
616
SysTrashPhotos(MessageParcel & data,MessageParcel & reply)617 int32_t MediaAssetsControllerService::SysTrashPhotos(MessageParcel &data, MessageParcel &reply)
618 {
619 MEDIA_INFO_LOG("enter SysTrashPhotos");
620 TrashPhotosReqBody reqBody;
621
622 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
623 if (ret != E_OK) {
624 MEDIA_ERR_LOG("SysTrashPhotos Read Request Error");
625 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
626 }
627 if (reqBody.uris.empty()) {
628 MEDIA_ERR_LOG("uris is empty");
629 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
630 }
631 ret = MediaAssetsService::GetInstance().TrashPhotos(reqBody.uris);
632 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
633 }
634
TrashPhotos(MessageParcel & data,MessageParcel & reply)635 int32_t MediaAssetsControllerService::TrashPhotos(MessageParcel &data, MessageParcel &reply)
636 {
637 MEDIA_INFO_LOG("enter TrashPhotos");
638 TrashPhotosReqBody reqBody;
639
640 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
641 if (ret != E_OK) {
642 MEDIA_ERR_LOG("TrashPhotos Read Request Error");
643 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
644 }
645 ret = ParameterUtils::CheckTrashPhotos(reqBody.uris);
646 if (ret != E_OK) {
647 MEDIA_ERR_LOG("uris is invalid");
648 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
649 }
650
651 ret = MediaAssetsService::GetInstance().TrashPhotos(reqBody.uris);
652 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
653 }
654
DeletePhotos(MessageParcel & data,MessageParcel & reply)655 int32_t MediaAssetsControllerService::DeletePhotos(MessageParcel &data, MessageParcel &reply)
656 {
657 MEDIA_INFO_LOG("enter DeletePhotos");
658 DeletePhotosReqBody reqBody;
659
660 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
661 if (ret != E_OK) {
662 MEDIA_ERR_LOG("DeletePhotos Read Request Error");
663 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
664 }
665 if (reqBody.uris.empty()) {
666 MEDIA_ERR_LOG("uris is empty");
667 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
668 }
669 ret = MediaAssetsService::GetInstance().DeletePhotos(reqBody.uris);
670 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
671 }
672
DeletePhotosCompleted(MessageParcel & data,MessageParcel & reply)673 int32_t MediaAssetsControllerService::DeletePhotosCompleted(MessageParcel &data, MessageParcel &reply)
674 {
675 MEDIA_INFO_LOG("enter DeletePhotosCompleted");
676 DeletePhotosCompletedReqBody reqBody;
677
678 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
679 if (ret != E_OK) {
680 MEDIA_ERR_LOG("DeletePhotosCompleted Read Request Error");
681 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
682 }
683 ret = ParameterUtils::CheckDeletePhotosCompleted(reqBody.fileIds);
684 if (ret != E_OK) {
685 MEDIA_ERR_LOG("fileIds is invalid");
686 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
687 }
688
689 ret = MediaAssetsService::GetInstance().DeletePhotosCompleted(reqBody.fileIds);
690 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
691 }
692
AssetChangeSetFavorite(MessageParcel & data,MessageParcel & reply)693 int32_t MediaAssetsControllerService::AssetChangeSetFavorite(MessageParcel &data, MessageParcel &reply)
694 {
695 MEDIA_INFO_LOG("enter AssetChangeSetFavorite");
696 AssetChangeReqBody reqBody;
697
698 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
699 if (ret != E_OK) {
700 MEDIA_ERR_LOG("AssetChangeSetFavorite Read Request Error");
701 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
702 }
703 if (reqBody.fileId <= 0) {
704 MEDIA_ERR_LOG("fileId is invalid");
705 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
706 }
707
708 ret = MediaAssetsService::GetInstance().AssetChangeSetFavorite(reqBody.fileId, reqBody.favorite);
709 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
710 }
711
AssetChangeSetHidden(MessageParcel & data,MessageParcel & reply)712 int32_t MediaAssetsControllerService::AssetChangeSetHidden(MessageParcel &data, MessageParcel &reply)
713 {
714 MEDIA_INFO_LOG("enter AssetChangeSetHidden");
715 AssetChangeReqBody reqBody;
716
717 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
718 if (ret != E_OK) {
719 MEDIA_ERR_LOG("AssetChangeSetHidden Read Request Error");
720 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
721 }
722 if (!ParameterUtils::IsPhotoUri(reqBody.uri)) {
723 MEDIA_ERR_LOG("uri is invalid");
724 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
725 }
726
727 ret = MediaAssetsService::GetInstance().AssetChangeSetHidden(reqBody.uri, reqBody.hidden);
728 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
729 }
730
AssetChangeSetUserComment(MessageParcel & data,MessageParcel & reply)731 int32_t MediaAssetsControllerService::AssetChangeSetUserComment(MessageParcel &data, MessageParcel &reply)
732 {
733 MEDIA_INFO_LOG("enter AssetChangeSetUserComment");
734 AssetChangeReqBody reqBody;
735
736 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
737 if (ret != E_OK) {
738 MEDIA_ERR_LOG("AssetChangeSetUserComment Read Request Error");
739 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
740 }
741 ret = ParameterUtils::CheckUserComment(reqBody);
742 if (ret != E_OK) {
743 MEDIA_ERR_LOG("params is invalid");
744 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
745 }
746
747 ret = MediaAssetsService::GetInstance().AssetChangeSetUserComment(reqBody.fileId, reqBody.userComment);
748 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
749 }
750
AssetChangeSetLocation(MessageParcel & data,MessageParcel & reply)751 int32_t MediaAssetsControllerService::AssetChangeSetLocation(MessageParcel &data, MessageParcel &reply)
752 {
753 MEDIA_INFO_LOG("enter AssetChangeSetLocation");
754 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_LOCATION);
755 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
756 DfxTimer dfxTimer(operationCode, timeout, true);
757 AssetChangeReqBody reqBody;
758
759 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
760 if (ret != E_OK) {
761 MEDIA_ERR_LOG("AssetChangeSetLocation Read Request Error");
762 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
763 }
764
765 if (reqBody.fileId <= 0) {
766 MEDIA_ERR_LOG("params is invalid");
767 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
768 }
769
770 auto dto = SetLocationDto::Create(reqBody);
771 ret = MediaAssetsService::GetInstance().AssetChangeSetLocation(dto);
772 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
773 }
774
AssetChangeSetTitle(MessageParcel & data,MessageParcel & reply)775 int32_t MediaAssetsControllerService::AssetChangeSetTitle(MessageParcel &data, MessageParcel &reply)
776 {
777 MEDIA_INFO_LOG("enter AssetChangeSetTitle");
778 AssetChangeReqBody reqBody;
779
780 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
781 if (ret != E_OK) {
782 MEDIA_ERR_LOG("AssetChangeSetTitle Read Request Error");
783 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
784 }
785
786 if (reqBody.fileId <= 0) {
787 MEDIA_ERR_LOG("params is invalid");
788 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
789 }
790
791 ret = MediaAssetsService::GetInstance().AssetChangeSetTitle(reqBody.fileId, reqBody.title);
792 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
793 }
794
AssetChangeSetEditData(MessageParcel & data,MessageParcel & reply)795 int32_t MediaAssetsControllerService::AssetChangeSetEditData(MessageParcel &data, MessageParcel &reply)
796 {
797 MEDIA_INFO_LOG("enter AssetChangeSetEditData");
798 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_SET_EDIT_DATA);
799 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
800 DfxTimer dfxTimer(operationCode, timeout, true);
801 AssetChangeReqBody reqBody;
802
803 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
804 if (ret != E_OK) {
805 MEDIA_ERR_LOG("AssetChangeSetEditData Read Request Error");
806 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
807 }
808
809 if (reqBody.values.IsEmpty()) {
810 MEDIA_ERR_LOG("params is invalid");
811 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
812 }
813
814 ret = MediaAssetsService::GetInstance().AssetChangeSetEditData(reqBody.values);
815 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
816 }
817
AssetChangeSubmitCache(MessageParcel & data,MessageParcel & reply)818 int32_t MediaAssetsControllerService::AssetChangeSubmitCache(MessageParcel &data, MessageParcel &reply)
819 {
820 MEDIA_INFO_LOG("enter AssetChangeSubmitCache");
821 SubmitCacheReqBody reqBody;
822
823 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
824 if (ret != E_OK) {
825 MEDIA_ERR_LOG("AssetChangeSubmitCache Read Request Error");
826 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
827 }
828
829 if (reqBody.values.IsEmpty()) {
830 MEDIA_ERR_LOG("params is invalid");
831 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
832 }
833 auto dto = SubmitCacheDto::Create(reqBody);
834 ret = MediaAssetsService::GetInstance().AssetChangeSubmitCache(dto);
835 if (ret != E_OK) {
836 MEDIA_ERR_LOG("AssetChangeSubmitCache Error");
837 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
838 }
839 auto respBody = dto.CreateRespBody();
840 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
841 }
842
AssetChangeCreateAsset(MessageParcel & data,MessageParcel & reply)843 int32_t MediaAssetsControllerService::AssetChangeCreateAsset(MessageParcel &data, MessageParcel &reply)
844 {
845 MEDIA_INFO_LOG("enter AssetChangeCreateAsset");
846 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_CREATE_ASSET);
847 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
848 DfxTimer dfxTimer(operationCode, timeout, true);
849 AssetChangeReqBody reqBody;
850
851 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
852 if (ret != E_OK) {
853 MEDIA_ERR_LOG("AssetChangeCreateAsset Read Request Error");
854 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
855 }
856
857 if (reqBody.values.IsEmpty()) {
858 MEDIA_ERR_LOG("params is invalid");
859 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
860 }
861 auto dto = AssetChangeCreateAssetDto::Create(reqBody);
862 ret = MediaAssetsService::GetInstance().AssetChangeCreateAsset(dto);
863 if (ret != E_OK) {
864 MEDIA_ERR_LOG("AssetChangeCreateAsset Error");
865 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
866 }
867 auto respBody = dto.CreateRespBody();
868 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
869 }
870
AssetChangeAddImage(MessageParcel & data,MessageParcel & reply)871 int32_t MediaAssetsControllerService::AssetChangeAddImage(MessageParcel &data, MessageParcel &reply)
872 {
873 MEDIA_INFO_LOG("enter AssetChangeAddImage");
874 AddImageReqBody reqBody;
875 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_ADD_IMAGE);
876 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
877 DfxTimer dfxTimer(operationCode, timeout, true);
878 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
879 if (ret != E_OK) {
880 MEDIA_ERR_LOG("AssetChangeAddImage Read Request Error");
881 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
882 }
883
884 if (reqBody.fileId <= 0) {
885 MEDIA_ERR_LOG("params is invalid");
886 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
887 }
888 auto dto = AddImageDto::Create(reqBody);
889 ret = MediaAssetsService::GetInstance().AssetChangeAddImage(dto);
890 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
891 }
892
SetCameraShotKey(MessageParcel & data,MessageParcel & reply)893 int32_t MediaAssetsControllerService::SetCameraShotKey(MessageParcel &data, MessageParcel &reply)
894 {
895 MEDIA_INFO_LOG("enter SetCameraShotKey");
896 AssetChangeReqBody reqBody;
897
898 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
899 if (ret != E_OK) {
900 MEDIA_ERR_LOG("SetCameraShotKey Read Request Error");
901 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
902 }
903
904 ret = ParameterUtils::CheckCameraShotKey(reqBody);
905 if (ret != E_OK) {
906 MEDIA_ERR_LOG("params is invalid");
907 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
908 }
909 ret = MediaAssetsService::GetInstance().SetCameraShotKey(reqBody.fileId, reqBody.cameraShotKey);
910 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
911 }
912
SaveCameraPhoto(MessageParcel & data,MessageParcel & reply)913 int32_t MediaAssetsControllerService::SaveCameraPhoto(MessageParcel &data, MessageParcel &reply)
914 {
915 MEDIA_INFO_LOG("enter SaveCameraPhoto");
916 SaveCameraPhotoReqBody reqBody;
917
918 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
919 if (ret != E_OK) {
920 MEDIA_ERR_LOG("SaveCameraPhoto Read Request Error");
921 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
922 }
923
924 if (reqBody.fileId <= 0) {
925 MEDIA_ERR_LOG("params is invalid");
926 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
927 }
928 auto dto = SaveCameraPhotoDto::Create(reqBody);
929 ret = MediaAssetsService::GetInstance().SaveCameraPhoto(dto);
930 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
931 }
932
DiscardCameraPhoto(MessageParcel & data,MessageParcel & reply)933 int32_t MediaAssetsControllerService::DiscardCameraPhoto(MessageParcel &data, MessageParcel &reply)
934 {
935 MEDIA_INFO_LOG("enter DiscardCameraPhoto");
936 AssetChangeReqBody reqBody;
937
938 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
939 if (ret != E_OK) {
940 MEDIA_ERR_LOG("DiscardCameraPhoto Read Request Error");
941 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
942 }
943
944 if (reqBody.fileId <= 0) {
945 MEDIA_ERR_LOG("params is invalid");
946 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
947 }
948 ret = MediaAssetsService::GetInstance().DiscardCameraPhoto(reqBody.fileId);
949 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
950 }
951
SetEffectMode(MessageParcel & data,MessageParcel & reply)952 int32_t MediaAssetsControllerService::SetEffectMode(MessageParcel &data, MessageParcel &reply)
953 {
954 MEDIA_INFO_LOG("enter SetEffectMode");
955 AssetChangeReqBody reqBody;
956
957 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
958 if (ret != E_OK) {
959 MEDIA_ERR_LOG("SetEffectMode Read Request Error");
960 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
961 }
962
963 if (reqBody.fileId <= 0|| !MediaFileUtils::CheckMovingPhotoEffectMode(reqBody.effectMode)) {
964 MEDIA_ERR_LOG("params is invalid");
965 return IPC::UserDefineIPC().WriteResponseBody(reply, -EINVAL);
966 }
967 ret = MediaAssetsService::GetInstance().SetEffectMode(reqBody.fileId, reqBody.effectMode);
968 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
969 }
970
SetOrientation(MessageParcel & data,MessageParcel & reply)971 int32_t MediaAssetsControllerService::SetOrientation(MessageParcel &data, MessageParcel &reply)
972 {
973 MEDIA_INFO_LOG("enter SetOrientation");
974 AssetChangeReqBody reqBody;
975
976 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
977 if (ret != E_OK) {
978 MEDIA_ERR_LOG("SetOrientation Read Request Error");
979 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
980 }
981
982 ret = ParameterUtils::CheckOrientation(reqBody);
983 if (ret != E_OK) {
984 MEDIA_ERR_LOG("params is invalid");
985 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
986 }
987 ret = MediaAssetsService::GetInstance().SetOrientation(reqBody.fileId, reqBody.orientation);
988 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
989 }
990
SetVideoEnhancementAttr(MessageParcel & data,MessageParcel & reply)991 int32_t MediaAssetsControllerService::SetVideoEnhancementAttr(MessageParcel &data, MessageParcel &reply)
992 {
993 MEDIA_INFO_LOG("enter SetVideoEnhancementAttr");
994 AssetChangeReqBody reqBody;
995 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::SET_VIDEO_ENHANCEMENT_ATTR);
996 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
997 DfxTimer dfxTimer(operationCode, timeout, true);
998 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
999 if (ret != E_OK) {
1000 MEDIA_ERR_LOG("SetVideoEnhancementAttr Read Request Error");
1001 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1002 }
1003
1004 ret = ParameterUtils::CheckVideoEnhancementAttr(reqBody);
1005 if (ret != E_OK) {
1006 MEDIA_ERR_LOG("params is invalid");
1007 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1008 }
1009 ret = MediaAssetsService::GetInstance().SetVideoEnhancementAttr(reqBody.fileId, reqBody.photoId, reqBody.path);
1010 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1011 }
1012
SetSupportedWatermarkType(MessageParcel & data,MessageParcel & reply)1013 int32_t MediaAssetsControllerService::SetSupportedWatermarkType(MessageParcel &data, MessageParcel &reply)
1014 {
1015 MEDIA_INFO_LOG("enter SetSupportedWatermarkType");
1016 AssetChangeReqBody reqBody;
1017 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::SET_SUPPORTED_WATERMARK_TYPE);
1018 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1019 DfxTimer dfxTimer(operationCode, timeout, true);
1020 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1021 if (ret != E_OK) {
1022 MEDIA_ERR_LOG("SetSupportedWatermarkType Read Request Error");
1023 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1024 }
1025
1026 ret = ParameterUtils::CheckWatermarkType(reqBody);
1027 if (ret != E_OK) {
1028 MEDIA_ERR_LOG("params is invalid");
1029 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1030 }
1031 ret = MediaAssetsService::GetInstance().SetSupportedWatermarkType(reqBody.fileId, reqBody.watermarkType);
1032 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1033 }
1034
GetAssets(MessageParcel & data,MessageParcel & reply,OHOS::Media::IPC::IPCContext & context)1035 int32_t MediaAssetsControllerService::GetAssets(
1036 MessageParcel &data, MessageParcel &reply, OHOS::Media::IPC::IPCContext &context)
1037 {
1038 GetAssetsReqBody reqBody;
1039 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1040 if (ret != E_OK) {
1041 MEDIA_ERR_LOG("Read Request Error");
1042 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1043 }
1044
1045 ret = ParameterUtils::CheckWhereClause(reqBody.predicates.GetWhereClause());
1046 if (ret != E_OK) {
1047 MEDIA_ERR_LOG("CheckWhereClause fialed");
1048 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1049 }
1050 GetAssetsDto dto = GetAssetsDto::Create(reqBody);
1051 if (context.GetByPassCode() == E_PERMISSION_DB_BYPASS) {
1052 int64_t tokenId = static_cast<int64_t>(PermissionUtils::GetTokenId());
1053 if (tokenId == 0) {
1054 MEDIA_ERR_LOG("Get tokenId fail");
1055 return IPC::UserDefineIPC().WriteResponseBody(reply, Media::E_PERMISSION_DENIED);
1056 }
1057 string caluse = AppUriPermissionColumn::APP_URI_PERMISSION_TABLE + "." + AppUriPermissionColumn::FILE_ID +
1058 " = " + PhotoColumn::PHOTOS_TABLE + "." + AppUriPermissionColumn::FILE_ID;
1059 dto.predicates.InnerJoin(AppUriPermissionColumn::APP_URI_PERMISSION_TABLE)->On({caluse});
1060 dto.predicates.EqualTo(AppUriPermissionColumn::APP_URI_PERMISSION_TABLE + "." +
1061 AppUriPermissionColumn::PERMISSION_TYPE, AppUriPermissionColumn::PERMISSION_PERSIST_READ_WRITE);
1062 dto.predicates.EqualTo(AppUriPermissionColumn::APP_URI_PERMISSION_TABLE + "." +
1063 AppUriPermissionColumn::TARGET_TOKENID, tokenId);
1064 MediaLibraryRdbUtils::CleanAmbiguousColumn(dto.columns, dto.predicates, PhotoColumn::PHOTOS_TABLE);
1065 }
1066
1067 auto resultSet = MediaAssetsService::GetInstance().GetAssets(dto);
1068 if (resultSet == nullptr) {
1069 MEDIA_ERR_LOG("resultSet is null");
1070 return IPC::UserDefineIPC().WriteResponseBody(reply, E_FAIL);
1071 }
1072 GetAssetsRespBody respBody;
1073 respBody.resultSet = resultSet;
1074 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
1075 }
1076
GetBurstAssets(MessageParcel & data,MessageParcel & reply,OHOS::Media::IPC::IPCContext & context)1077 int32_t MediaAssetsControllerService::GetBurstAssets(
1078 MessageParcel &data, MessageParcel &reply, OHOS::Media::IPC::IPCContext &context)
1079 {
1080 MEDIA_INFO_LOG("enter");
1081 GetAssetsReqBody reqBody;
1082 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1083 if (ret != E_OK) {
1084 MEDIA_ERR_LOG("Read Request Error");
1085 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1086 }
1087
1088 ret = ParameterUtils::CheckWhereClause(reqBody.predicates.GetWhereClause());
1089 if (ret != E_OK || reqBody.burstKey.empty()) {
1090 MEDIA_ERR_LOG("CheckWhereClause fialed or burstKey is empty");
1091 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1092 }
1093 GetAssetsDto dto = GetAssetsDto::Create(reqBody);
1094 if (context.GetByPassCode() == E_PERMISSION_DB_BYPASS) {
1095 int64_t tokenId = static_cast<int64_t>(PermissionUtils::GetTokenId());
1096 if (tokenId == 0) {
1097 MEDIA_ERR_LOG("Get tokenId fail");
1098 return IPC::UserDefineIPC().WriteResponseBody(reply, Media::E_PERMISSION_DENIED);
1099 }
1100 string caluse = AppUriPermissionColumn::APP_URI_PERMISSION_TABLE + "." + AppUriPermissionColumn::FILE_ID +
1101 " = " + PhotoColumn::PHOTOS_TABLE + "." + AppUriPermissionColumn::FILE_ID;
1102 dto.predicates.InnerJoin(AppUriPermissionColumn::APP_URI_PERMISSION_TABLE)->On({caluse});
1103 dto.predicates.EqualTo(AppUriPermissionColumn::APP_URI_PERMISSION_TABLE + "." +
1104 AppUriPermissionColumn::PERMISSION_TYPE, AppUriPermissionColumn::PERMISSION_PERSIST_READ_WRITE);
1105 dto.predicates.EqualTo(AppUriPermissionColumn::APP_URI_PERMISSION_TABLE + "." +
1106 AppUriPermissionColumn::TARGET_TOKENID, tokenId);
1107 MediaLibraryRdbUtils::CleanAmbiguousColumn(dto.columns, dto.predicates, PhotoColumn::PHOTOS_TABLE);
1108 }
1109 dto.predicates.OrderByAsc(MediaColumn::MEDIA_NAME);
1110 auto resultSet = MediaAssetsService::GetInstance().GetAssets(dto);
1111 if (resultSet == nullptr) {
1112 MEDIA_ERR_LOG("resultSet is null");
1113 return IPC::UserDefineIPC().WriteResponseBody(reply, E_FAIL);
1114 }
1115 GetAssetsRespBody respBody;
1116 respBody.resultSet = resultSet;
1117 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
1118 }
1119
GetAllDuplicateAssets(MessageParcel & data,MessageParcel & reply)1120 int32_t MediaAssetsControllerService::GetAllDuplicateAssets(MessageParcel &data, MessageParcel &reply)
1121 {
1122 MEDIA_INFO_LOG("enter");
1123 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::FIND_ALL_DUPLICATE_ASSETS);
1124 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1125 DfxTimer dfxTimer(operationCode, timeout, true);
1126 GetAssetsReqBody reqBody;
1127 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1128 if (ret != E_OK) {
1129 MEDIA_ERR_LOG("Read Request Error");
1130 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1131 }
1132
1133 ret = ParameterUtils::CheckWhereClause(reqBody.predicates.GetWhereClause());
1134 if (ret != E_OK) {
1135 MEDIA_ERR_LOG("CheckWhereClause fialed");
1136 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1137 }
1138 GetAssetsDto dto = GetAssetsDto::Create(reqBody);
1139 auto resultSet = MediaAssetsService::GetInstance().GetAllDuplicateAssets(dto);
1140 if (resultSet == nullptr) {
1141 MEDIA_ERR_LOG("resultSet is null");
1142 return IPC::UserDefineIPC().WriteResponseBody(reply, E_FAIL);
1143 }
1144 GetAssetsRespBody respBody;
1145 respBody.resultSet = resultSet;
1146 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
1147 }
1148
GetDuplicateAssetsToDelete(MessageParcel & data,MessageParcel & reply)1149 int32_t MediaAssetsControllerService::GetDuplicateAssetsToDelete(MessageParcel &data, MessageParcel &reply)
1150 {
1151 MEDIA_INFO_LOG("enter");
1152 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::FIND_DUPLICATE_ASSETS_TO_DELETE);
1153 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1154 DfxTimer dfxTimer(operationCode, timeout, true);
1155 GetAssetsReqBody reqBody;
1156 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1157 if (ret != E_OK) {
1158 MEDIA_ERR_LOG("Read Request Error");
1159 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1160 }
1161
1162 ret = ParameterUtils::CheckWhereClause(reqBody.predicates.GetWhereClause());
1163 if (ret != E_OK) {
1164 MEDIA_ERR_LOG("CheckWhereClause fialed");
1165 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1166 }
1167 GetAssetsDto dto = GetAssetsDto::Create(reqBody);
1168 auto resultSet = MediaAssetsService::GetInstance().GetDuplicateAssetsToDelete(dto);
1169 if (resultSet == nullptr) {
1170 MEDIA_ERR_LOG("resultSet is null");
1171 return IPC::UserDefineIPC().WriteResponseBody(reply, E_FAIL);
1172 }
1173 GetAssetsRespBody respBody;
1174 respBody.resultSet = resultSet;
1175 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
1176 }
1177
GetIndexConstructProgress(MessageParcel & data,MessageParcel & reply)1178 int32_t MediaAssetsControllerService::GetIndexConstructProgress(MessageParcel &data, MessageParcel &reply)
1179 {
1180 MEDIA_INFO_LOG("enter");
1181 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::GET_INDEX_CONSTRUCT_PROGRESS);
1182 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1183 DfxTimer dfxTimer(operationCode, timeout, true);
1184 std::string indexProgress;
1185 auto ret = MediaAssetsService::GetInstance().GetIndexConstructProgress(indexProgress);
1186 if (ret != E_OK) {
1187 MEDIA_ERR_LOG("get index construct progress failed, ret: %{public}d", ret);
1188 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1189 }
1190 GetIndexConstructProgressRespBody respBody;
1191 respBody.indexProgress = indexProgress;
1192 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
1193 }
1194
PublicCreateAsset(MessageParcel & data,MessageParcel & reply)1195 int32_t MediaAssetsControllerService::PublicCreateAsset(MessageParcel &data, MessageParcel &reply)
1196 {
1197 CreateAssetReqBody reqBody;
1198 CreateAssetRespBody respBody;
1199 MEDIA_INFO_LOG("enter PublicCreateAsset");
1200 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_PUBLIC_CREATE_ASSET);
1201 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1202 DfxTimer dfxTimer(operationCode, timeout, true);
1203 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1204 if (ret != E_OK) {
1205 MEDIA_ERR_LOG("PublicCreateAsset Read Request Error");
1206 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1207 }
1208
1209 ret = ParameterUtils::CheckPublicCreateAsset(reqBody);
1210 if (ret != E_OK) {
1211 MEDIA_ERR_LOG("CheckPublicCreateAsset ret:%{public}d", ret);
1212 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1213 }
1214
1215 CreateAssetDto dto(reqBody);
1216 ret = MediaAssetsService::GetInstance().CreateAsset(dto);
1217 return IPC::UserDefineIPC().WriteResponseBody(reply, dto.GetRespBody(), ret);
1218 }
1219
SystemCreateAsset(MessageParcel & data,MessageParcel & reply)1220 int32_t MediaAssetsControllerService::SystemCreateAsset(MessageParcel &data, MessageParcel &reply)
1221 {
1222 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET);
1223 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1224 DfxTimer dfxTimer(operationCode, timeout, true);
1225 CreateAssetReqBody reqBody;
1226 CreateAssetRespBody respBody;
1227 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1228 if (ret != E_OK) {
1229 MEDIA_ERR_LOG("SystemCreateAsset Read Request Error");
1230 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1231 }
1232
1233 ret = ParameterUtils::CheckSystemCreateAsset(reqBody);
1234 if (ret != E_OK) {
1235 MEDIA_ERR_LOG("CheckSystemCreateAsset ret:%{public}d", ret);
1236 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1237 }
1238
1239 CreateAssetDto dto(reqBody);
1240 (int32_t)ParameterUtils::GetTitleAndExtension(dto.displayName, dto.title, dto.extension);
1241 ret = MediaAssetsService::GetInstance().CreateAsset(dto);
1242 return IPC::UserDefineIPC().WriteResponseBody(reply, dto.GetRespBody(), ret);
1243 }
1244
PublicCreateAssetForApp(MessageParcel & data,MessageParcel & reply)1245 int32_t MediaAssetsControllerService::PublicCreateAssetForApp(MessageParcel &data, MessageParcel &reply)
1246 {
1247 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_PUBLIC_CREATE_ASSET_FOR_APP);
1248 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1249 DfxTimer dfxTimer(operationCode, timeout, true);
1250 CreateAssetForAppReqBody reqBody;
1251 CreateAssetForAppRespBody respBody;
1252 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1253 if (ret != E_OK) {
1254 MEDIA_ERR_LOG("CreateAssetForApp Read Request Error");
1255 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1256 }
1257
1258 ret = ParameterUtils::CheckPublicCreateAssetForApp(reqBody);
1259 if (ret != E_OK) {
1260 MEDIA_ERR_LOG("CheckPublicCreateAssetForApp ret:%{public}d", ret);
1261 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1262 }
1263
1264 CreateAssetDto dto(reqBody);
1265 ret = MediaAssetsService::GetInstance().CreateAssetForApp(dto);
1266 return IPC::UserDefineIPC().WriteResponseBody(reply, dto.GetRespBody(), ret);
1267 }
1268
SystemCreateAssetForApp(MessageParcel & data,MessageParcel & reply)1269 int32_t MediaAssetsControllerService::SystemCreateAssetForApp(MessageParcel &data, MessageParcel &reply)
1270 {
1271 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET_FOR_APP);
1272 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1273 DfxTimer dfxTimer(operationCode, timeout, true);
1274 CreateAssetForAppReqBody reqBody;
1275 CreateAssetForAppRespBody respBody;
1276 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1277 if (ret != E_OK) {
1278 MEDIA_ERR_LOG("CreateAssetForApp Read Request Error");
1279 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1280 }
1281
1282 ret = ParameterUtils::CheckSystemCreateAssetForApp(reqBody);
1283 if (ret != E_OK) {
1284 MEDIA_ERR_LOG("CheckSystemCreateAssetForApp ret:%{public}d", ret);
1285 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1286 }
1287
1288 CreateAssetDto dto(reqBody);
1289 ret = MediaAssetsService::GetInstance().CreateAssetForApp(dto);
1290 return IPC::UserDefineIPC().WriteResponseBody(reply, dto.GetRespBody(), ret);
1291 }
1292
CreateAssetForAppWithAlbum(MessageParcel & data,MessageParcel & reply)1293 int32_t MediaAssetsControllerService::CreateAssetForAppWithAlbum(MessageParcel &data, MessageParcel &reply)
1294 {
1295 uint32_t operationCode = static_cast<uint32_t>(
1296 MediaLibraryBusinessCode::PAH_SYSTEM_CREATE_ASSET_FOR_APP_WITH_ALBUM);
1297 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1298 DfxTimer dfxTimer(operationCode, timeout, true);
1299 CreateAssetForAppReqBody reqBody;
1300 CreateAssetForAppRespBody respBody;
1301 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1302 if (ret != E_OK) {
1303 MEDIA_ERR_LOG("CreateAssetForAppWithAlbum Read Request Error");
1304 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1305 }
1306
1307 ret = ParameterUtils::CheckCreateAssetForAppWithAlbum(reqBody);
1308 if (ret != E_OK) {
1309 MEDIA_ERR_LOG("CheckCreateAssetForAppWithAlbum ret:%{public}d", ret);
1310 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1311 }
1312
1313 CreateAssetDto dto(reqBody);
1314 ret = MediaAssetsService::GetInstance().CreateAssetForAppWithAlbum(dto);
1315 return IPC::UserDefineIPC().WriteResponseBody(reply, dto.GetRespBody(), ret);
1316 }
1317
SetAssetTitle(MessageParcel & data,MessageParcel & reply)1318 int32_t MediaAssetsControllerService::SetAssetTitle(MessageParcel &data, MessageParcel &reply)
1319 {
1320 ModifyAssetsReqBody reqBody;
1321 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1322 if (ret != E_OK) {
1323 MEDIA_ERR_LOG("SetAssetTitle Read Request Error");
1324 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1325 }
1326
1327 ret = ParameterUtils::CheckSetAssetTitle(reqBody);
1328 if (ret != E_OK) {
1329 MEDIA_ERR_LOG("CheckSetAssetTitle ret:%{public}d", ret);
1330 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1331 }
1332
1333 ret = MediaAssetsService::GetInstance().SetAssetTitle(reqBody.fileIds.front(), reqBody.title);
1334 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1335 }
1336
SetAssetPending(MessageParcel & data,MessageParcel & reply)1337 int32_t MediaAssetsControllerService::SetAssetPending(MessageParcel &data, MessageParcel &reply)
1338 {
1339 ModifyAssetsReqBody reqBody;
1340 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1341 if (ret != E_OK) {
1342 MEDIA_ERR_LOG("SetAssetPending Read Request Error");
1343 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1344 }
1345
1346 ret = ParameterUtils::CheckSetAssetPending(reqBody);
1347 if (ret != E_OK) {
1348 MEDIA_ERR_LOG("CheckSetAssetPending ret:%{public}d", ret);
1349 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1350 }
1351
1352 ret = MediaAssetsService::GetInstance().SetAssetPending(reqBody.fileIds.front(), reqBody.pending);
1353 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1354 }
1355
SetAssetsFavorite(MessageParcel & data,MessageParcel & reply)1356 int32_t MediaAssetsControllerService::SetAssetsFavorite(MessageParcel &data, MessageParcel &reply)
1357 {
1358 ModifyAssetsReqBody reqBody;
1359 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1360 if (ret != E_OK) {
1361 MEDIA_ERR_LOG("SetAssetsFavorite Read Request Error");
1362 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1363 }
1364
1365 ret = ParameterUtils::CheckSetAssetsFavorite(reqBody);
1366 if (ret != E_OK) {
1367 MEDIA_ERR_LOG("CheckSetAssetsFavorite ret:%{public}d", ret);
1368 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1369 }
1370
1371 ret = MediaAssetsService::GetInstance().SetAssetsFavorite(reqBody.fileIds, reqBody.favorite);
1372 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1373 }
1374
SetAssetsHiddenStatus(MessageParcel & data,MessageParcel & reply)1375 int32_t MediaAssetsControllerService::SetAssetsHiddenStatus(MessageParcel &data, MessageParcel &reply)
1376 {
1377 ModifyAssetsReqBody reqBody;
1378 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1379 if (ret != E_OK) {
1380 MEDIA_ERR_LOG("SetAssetsHiddenStatus Read Request Error");
1381 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1382 }
1383
1384 ret = ParameterUtils::CheckSetAssetsHiddenStatus(reqBody);
1385 if (ret != E_OK) {
1386 MEDIA_ERR_LOG("CheckSetAssetsHiddenStatus ret:%{public}d", ret);
1387 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1388 }
1389
1390 ret = MediaAssetsService::GetInstance().SetAssetsHiddenStatus(reqBody.fileIds, reqBody.hiddenStatus);
1391 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1392 }
1393
SetAssetsRecentShowStatus(MessageParcel & data,MessageParcel & reply)1394 int32_t MediaAssetsControllerService::SetAssetsRecentShowStatus(MessageParcel &data, MessageParcel &reply)
1395 {
1396 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_SYSTEM_BATCH_SET_RECENT_SHOW);
1397 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1398 DfxTimer dfxTimer(operationCode, timeout, true);
1399 ModifyAssetsReqBody reqBody;
1400 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1401 if (ret != E_OK) {
1402 MEDIA_ERR_LOG("SetAssetsRecentShowStatus Read Request Error");
1403 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1404 }
1405
1406 ret = ParameterUtils::CheckSetAssetsRecentShowStatus(reqBody);
1407 if (ret != E_OK) {
1408 MEDIA_ERR_LOG("CheckSetAssetsRecentShowStatus ret:%{public}d", ret);
1409 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1410 }
1411
1412 ret = MediaAssetsService::GetInstance().SetAssetsRecentShowStatus(reqBody.fileIds, reqBody.recentShowStatus);
1413 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1414 }
1415
SetAssetsUserComment(MessageParcel & data,MessageParcel & reply)1416 int32_t MediaAssetsControllerService::SetAssetsUserComment(MessageParcel &data, MessageParcel &reply)
1417 {
1418 ModifyAssetsReqBody reqBody;
1419 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1420 if (ret != E_OK) {
1421 MEDIA_ERR_LOG("SetAssetsUserComment Read Request Error");
1422 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1423 }
1424
1425 ret = ParameterUtils::CheckSetAssetsUserComment(reqBody);
1426 if (ret != E_OK) {
1427 MEDIA_ERR_LOG("CheckSetAssetsUserComment ret:%{public}d", ret);
1428 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1429 }
1430
1431 ret = MediaAssetsService::GetInstance().SetAssetsUserComment(reqBody.fileIds, reqBody.userComment);
1432 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1433 }
1434
AddAssetVisitCount(MessageParcel & data,MessageParcel & reply)1435 int32_t MediaAssetsControllerService::AddAssetVisitCount(MessageParcel &data, MessageParcel &reply)
1436 {
1437 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_ADD_ASSET_VISIT_COUNT);
1438 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1439 DfxTimer dfxTimer(operationCode, timeout, true);
1440 AddAssetVisitCountReqBody reqBody;
1441 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1442 if (ret != E_OK) {
1443 MEDIA_ERR_LOG("SetAssetsUserComment Read Request Error");
1444 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1445 }
1446
1447 ret = ParameterUtils::CheckAddAssetVisitCount(reqBody.fileId, reqBody.visitType);
1448 if (ret != E_OK) {
1449 MEDIA_ERR_LOG("CheckAddAssetVisitCount ret:%{public}d", ret);
1450 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1451 }
1452
1453 ret = MediaAssetsService::GetInstance().AddAssetVisitCount(reqBody.fileId, reqBody.visitType);
1454 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1455 }
1456
GetAssetAnalysisData(MessageParcel & data,MessageParcel & reply)1457 int32_t MediaAssetsControllerService::GetAssetAnalysisData(MessageParcel &data, MessageParcel &reply)
1458 {
1459 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GET_ASSET_ANALYSIS_DATA);
1460 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1461 DfxTimer dfxTimer(operationCode, timeout, true);
1462 GetAssetAnalysisDataReqBody reqBody;
1463 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1464 if (ret != E_OK) {
1465 MEDIA_ERR_LOG("GetAssetAnalysisData Read Request Error");
1466 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1467 }
1468
1469 GetAssetAnalysisDataDto dto;
1470 dto.fileId = reqBody.fileId;
1471 dto.language = reqBody.language;
1472 dto.analysisType = reqBody.analysisType;
1473 dto.analysisTotal = reqBody.analysisTotal;
1474 ret = MediaAssetsService::GetInstance().GetAssetAnalysisData(dto);
1475 if (ret != E_OK) {
1476 MEDIA_ERR_LOG("GetAssetAnalysisData failed, ret:%{public}d", ret);
1477 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1478 }
1479
1480 GetAssetAnalysisDataRespBody respBody;
1481 respBody.resultSet = std::move(dto.resultSet);
1482 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody);
1483 }
1484
CloneAsset(MessageParcel & data,MessageParcel & reply)1485 int32_t MediaAssetsControllerService::CloneAsset(MessageParcel &data, MessageParcel &reply)
1486 {
1487 MEDIA_INFO_LOG("enter CloneAsset");
1488 CloneAssetReqBody reqBody;
1489
1490 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1491 if (ret != E_OK) {
1492 MEDIA_ERR_LOG("CloneAsset Read Request Error");
1493 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1494 }
1495 string extension = MediaFileUtils::SplitByChar(reqBody.displayName, '.');
1496 string displayName = reqBody.title + "." + extension;
1497 if (MediaFileUtils::CheckDisplayName(displayName, true) != E_OK) {
1498 MEDIA_ERR_LOG("CloneAsset invalid params");
1499 return IPC::UserDefineIPC().WriteResponseBody(reply, E_INVALID_VALUES);
1500 }
1501
1502 CloneAssetDto cloneAssetDto;
1503 cloneAssetDto.fileId = reqBody.fileId;
1504 cloneAssetDto.title = reqBody.title;
1505 int32_t newAssetId = MediaAssetsService::GetInstance().CloneAsset(cloneAssetDto);
1506 return IPC::UserDefineIPC().WriteResponseBody(reply, newAssetId);
1507 }
1508
ConvertFormat(MessageParcel & data,MessageParcel & reply)1509 int32_t MediaAssetsControllerService::ConvertFormat(MessageParcel &data, MessageParcel &reply)
1510 {
1511 MEDIA_INFO_LOG("enter ConvertFormat");
1512 ConvertFormatReqBody reqBody;
1513
1514 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1515 if (ret != E_OK) {
1516 MEDIA_ERR_LOG("ConvertFormat Read Request Error");
1517 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1518 }
1519
1520 ConvertFormatDto convertFormatDto;
1521 convertFormatDto.fileId = reqBody.fileId;
1522 convertFormatDto.title = reqBody.title;
1523 convertFormatDto.extension = reqBody.extension;
1524 int32_t newAssetId = MediaAssetsService::GetInstance().ConvertFormat(convertFormatDto);
1525 if (newAssetId < 0) {
1526 MEDIA_ERR_LOG("ConvertFormat failed, ret: %{public}d", newAssetId);
1527 if (newAssetId == E_INVALID_VALUES) {
1528 return IPC::UserDefineIPC().WriteResponseBody(reply, E_PARAM_CONVERT_FORMAT);
1529 } else {
1530 return IPC::UserDefineIPC().WriteResponseBody(reply, E_INNER_CONVERT_FORMAT);
1531 }
1532 } else {
1533 return IPC::UserDefineIPC().WriteResponseBody(reply, newAssetId);
1534 }
1535 }
1536
RevertToOriginal(MessageParcel & data,MessageParcel & reply)1537 int32_t MediaAssetsControllerService::RevertToOriginal(MessageParcel &data, MessageParcel &reply)
1538 {
1539 MEDIA_INFO_LOG("enter RevertToOriginal");
1540 RevertToOriginalReqBody reqBody;
1541
1542 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1543 if (ret != E_OK) {
1544 MEDIA_ERR_LOG("RevertToOriginal Read Request Error");
1545 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1546 }
1547 RevertToOriginalDto revertToOriginalDto;
1548 revertToOriginalDto.fileId = reqBody.fileId;
1549 revertToOriginalDto.fileUri = reqBody.fileUri;
1550
1551 ret = MediaAssetsService::GetInstance().RevertToOriginal(revertToOriginalDto);
1552 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1553 }
1554
UpdateGalleryFormInfo(MessageParcel & data,MessageParcel & reply)1555 int32_t MediaAssetsControllerService::UpdateGalleryFormInfo(MessageParcel &data, MessageParcel &reply)
1556 {
1557 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::UPDATE_GALLERY_FORM_INFO);
1558 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1559 DfxTimer dfxTimer(operationCode, timeout, true);
1560 MEDIA_INFO_LOG("enter UpdateGalleryFormInfo");
1561 FormInfoReqBody reqBody;
1562 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1563 if (ret != E_OK) {
1564 MEDIA_ERR_LOG("UpdateGalleryFormInfo Read Request Error");
1565 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1566 }
1567 ret = ParameterUtils::CheckFormIds(reqBody.formIds);
1568 FormInfoDto formInfoDto;
1569 formInfoDto.formIds = reqBody.formIds;
1570 formInfoDto.fileUris = reqBody.fileUris;
1571 bool cond = (formInfoDto.formIds.size() != formInfoDto.fileUris.size()) || formInfoDto.formIds.empty()
1572 || formInfoDto.fileUris.empty();
1573 if (cond) {
1574 MEDIA_ERR_LOG("formIds or fileUris is empty or count not equal");
1575 ret = E_GET_PRAMS_FAIL;
1576 }
1577 if (formInfoDto.formIds.size() > FACARD_MAX_REGISTER_OBSERVER &&
1578 formInfoDto.fileUris.size() > FACARD_MAX_REGISTER_OBSERVER) {
1579 MEDIA_INFO_LOG("registered uri exceeds the maximum limit, uri size:%{public}d",
1580 static_cast<int32_t>(formInfoDto.formIds.size()));
1581 formInfoDto.formIds = std::vector<std::string>(formInfoDto.formIds.begin(),
1582 formInfoDto.formIds.begin() + FACARD_MAX_REGISTER_OBSERVER);
1583 formInfoDto.fileUris = std::vector<std::string>(formInfoDto.fileUris.begin(),
1584 formInfoDto.fileUris.begin() + FACARD_MAX_REGISTER_OBSERVER);
1585 }
1586 if (ret == E_OK) {
1587 ret = MediaAssetsService::GetInstance().RemoveGalleryFormInfo(formInfoDto.formIds.front());
1588 ret = MediaAssetsService::GetInstance().SaveGalleryFormInfo(formInfoDto);
1589 }
1590 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1591 }
1592
SubmitCloudEnhancementTasks(MessageParcel & data,MessageParcel & reply)1593 int32_t MediaAssetsControllerService::SubmitCloudEnhancementTasks(MessageParcel &data, MessageParcel &reply)
1594 {
1595 MEDIA_INFO_LOG("enter SubmitCloudEnhancementTasks");
1596 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::SUBMIT_CLOUD_ENHANCEMENT_TASKS);
1597 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1598 DfxTimer dfxTimer(operationCode, timeout, true);
1599 CloudEnhancementReqBody reqBody;
1600 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1601 if (ret != E_OK) {
1602 MEDIA_ERR_LOG("SubmitCloudEnhancementTasks Read Request Error");
1603 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1604 }
1605 bool isValid = false;
1606 for (auto uri : reqBody.fileUris) {
1607 isValid = ParameterUtils::IsPhotoUri(uri);
1608 }
1609 if (!isValid) {
1610 MEDIA_ERR_LOG("fileUris in params is invalid");
1611 ret = E_GET_PRAMS_FAIL;
1612 }
1613 CloudEnhancementDto dto;
1614 dto.hasCloudWatermark = reqBody.hasCloudWatermark;
1615 dto.triggerMode = reqBody.triggerMode;
1616 dto.fileUris = reqBody.fileUris;
1617 if (ret == E_OK) {
1618 ret = MediaAssetsService::GetInstance().SubmitCloudEnhancementTasks(dto);
1619 }
1620 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1621 }
1622
PrioritizeCloudEnhancementTask(MessageParcel & data,MessageParcel & reply)1623 int32_t MediaAssetsControllerService::PrioritizeCloudEnhancementTask(MessageParcel &data, MessageParcel &reply)
1624 {
1625 MEDIA_INFO_LOG("enter PrioritizeCloudEnhancementTask");
1626 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PRIORITIZE_CLOUD_ENHANCEMENT_TASK);
1627 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1628 DfxTimer dfxTimer(operationCode, timeout, true);
1629 CloudEnhancementReqBody reqBody;
1630 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1631 if (ret != E_OK) {
1632 MEDIA_ERR_LOG("PrioritizeCloudEnhancementTask Read Request Error");
1633 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1634 }
1635 bool isValid = false;
1636 for (auto uri : reqBody.fileUris) {
1637 isValid = ParameterUtils::IsPhotoUri(uri);
1638 }
1639 if (!isValid) {
1640 MEDIA_ERR_LOG("fileUris in params is invalid");
1641 ret = E_GET_PRAMS_FAIL;
1642 }
1643 CloudEnhancementDto dto;
1644 dto.fileUris = reqBody.fileUris;
1645 if (ret == E_OK) {
1646 ret = MediaAssetsService::GetInstance().PrioritizeCloudEnhancementTask(dto);
1647 }
1648 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1649 }
1650
GrantPhotoUriPermissionInner(MessageParcel & data,MessageParcel & reply)1651 int32_t MediaAssetsControllerService::GrantPhotoUriPermissionInner(MessageParcel &data, MessageParcel &reply)
1652 {
1653 MEDIA_INFO_LOG("enter GrantPhotoUriPermissionInner");
1654 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GRANT_PHOTO_URI_PERMISSION);
1655 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1656 DfxTimer dfxTimer(operationCode, timeout, true);
1657 GrantUrisPermissionInnerReqBody reqBody;
1658
1659 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1660 if (ret != E_OK) {
1661 MEDIA_ERR_LOG("GrantPhotoUriPermissionInner Read Request Error");
1662 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1663 }
1664 GrantUriPermissionInnerDto grantUriPermInnerDto;
1665 grantUriPermInnerDto.tokenId = reqBody.tokenId;
1666 grantUriPermInnerDto.srcTokenId = reqBody.srcTokenId;
1667 grantUriPermInnerDto.appId = reqBody.appId;
1668 grantUriPermInnerDto.fileIds = reqBody.fileIds;
1669 grantUriPermInnerDto.uriTypes = reqBody.uriTypes;
1670 grantUriPermInnerDto.permissionTypes = reqBody.permissionTypes;
1671 grantUriPermInnerDto.hideSensitiveType = reqBody.hideSensitiveType;
1672
1673 ret = MediaAssetsService::GetInstance().GrantPhotoUriPermissionInner(grantUriPermInnerDto);
1674 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1675 }
1676
CancelCloudEnhancementTasks(MessageParcel & data,MessageParcel & reply)1677 int32_t MediaAssetsControllerService::CancelCloudEnhancementTasks(MessageParcel &data, MessageParcel &reply)
1678 {
1679 MEDIA_INFO_LOG("enter CancelCloudEnhancementTasks");
1680 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::CANCEL_CLOUD_ENHANCEMENT_TASKS);
1681 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1682 DfxTimer dfxTimer(operationCode, timeout, true);
1683 CloudEnhancementReqBody reqBody;
1684 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1685 if (ret != E_OK) {
1686 MEDIA_ERR_LOG("CancelCloudEnhancementTasks Read Request Error");
1687 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1688 }
1689 bool isValid = false;
1690 for (auto uri : reqBody.fileUris) {
1691 isValid = ParameterUtils::IsPhotoUri(uri);
1692 }
1693 if (!isValid) {
1694 MEDIA_ERR_LOG("fileUris in params is invalid");
1695 ret = E_GET_PRAMS_FAIL;
1696 }
1697 CloudEnhancementDto dto;
1698 dto.fileUris = reqBody.fileUris;
1699 if (ret == E_OK) {
1700 ret = MediaAssetsService::GetInstance().CancelCloudEnhancementTasks(dto);
1701 }
1702 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1703 }
1704
CancelAllCloudEnhancementTasks(MessageParcel & data,MessageParcel & reply)1705 int32_t MediaAssetsControllerService::CancelAllCloudEnhancementTasks(MessageParcel &data, MessageParcel &reply)
1706 {
1707 MEDIA_INFO_LOG("enter CancelAllCloudEnhancementTasks");
1708 CloudEnhancementReqBody reqBody;
1709 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1710 if (ret != E_OK) {
1711 MEDIA_ERR_LOG("CancelAllCloudEnhancementTasks Read Request Error");
1712 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1713 }
1714 if (ret == E_OK) {
1715 ret = MediaAssetsService::GetInstance().CancelAllCloudEnhancementTasks();
1716 }
1717 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1718 }
1719
StartDownloadCloudMedia(MessageParcel & data,MessageParcel & reply)1720 int32_t MediaAssetsControllerService::StartDownloadCloudMedia(MessageParcel &data, MessageParcel &reply)
1721 {
1722 MEDIA_INFO_LOG("enter StartDownloadCloudMedia");
1723 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::START_DOWNLOAD_CLOUDMEDIA);
1724 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1725 DfxTimer dfxTimer(operationCode, timeout, true);
1726 StartDownloadCloudMediaReqBody reqBody;
1727 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1728 if (ret != E_OK) {
1729 MEDIA_ERR_LOG("StartDownloadCloudMedia Read Request Error");
1730 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1731 }
1732 CloudMediaDownloadType downloadType = static_cast<CloudMediaDownloadType>(reqBody.cloudMediaType);
1733
1734 if (downloadType != CloudMediaDownloadType::DOWNLOAD_FORCE &&
1735 downloadType != CloudMediaDownloadType::DOWNLOAD_GENTLE) {
1736 ret = E_INVALID_VALUES;
1737 MEDIA_ERR_LOG("StartDownloadCloudMedia error, err param");
1738 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1739 }
1740
1741 ret = MediaAssetsService::GetInstance().StartDownloadCloudMedia(downloadType);
1742 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1743 }
1744
PauseDownloadCloudMedia(MessageParcel & data,MessageParcel & reply)1745 int32_t MediaAssetsControllerService::PauseDownloadCloudMedia(MessageParcel &data, MessageParcel &reply)
1746 {
1747 MEDIA_INFO_LOG("enter PauseDownloadCloudMedia");
1748 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAUSE_DOWNLOAD_CLOUDMEDIA);
1749 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1750 DfxTimer dfxTimer(operationCode, timeout, true);
1751 int32_t ret = MediaAssetsService::GetInstance().PauseDownloadCloudMedia();
1752 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1753 }
1754
CancelDownloadCloudMedia(MessageParcel & data,MessageParcel & reply)1755 int32_t MediaAssetsControllerService::CancelDownloadCloudMedia(MessageParcel &data, MessageParcel &reply)
1756 {
1757 MEDIA_INFO_LOG("enter CancelDownloadCloudMedia");
1758 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::CANCEL_DOWNLOAD_CLOUDMEDIA);
1759 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1760 DfxTimer dfxTimer(operationCode, timeout, true);
1761 int32_t ret = MediaAssetsService::GetInstance().CancelDownloadCloudMedia();
1762 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1763 }
1764
RetainCloudMediaAsset(MessageParcel & data,MessageParcel & reply)1765 int32_t MediaAssetsControllerService::RetainCloudMediaAsset(MessageParcel &data, MessageParcel &reply)
1766 {
1767 MEDIA_INFO_LOG("enter RetainCloudMediaAsset");
1768 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::RETAIN_CLOUDMEDIA_ASSET);
1769 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1770 DfxTimer dfxTimer(operationCode, timeout, true);
1771 RetainCloudMediaAssetReqBody reqBody;
1772 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1773 if (ret != E_OK) {
1774 MEDIA_ERR_LOG("StartDownloadCloudMedia Read Request Error");
1775 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1776 }
1777
1778 auto cloudMediaRetainType = static_cast<CloudMediaRetainType>(reqBody.cloudMediaRetainType);
1779 if (cloudMediaRetainType == CloudMediaRetainType::RETAIN_FORCE ||
1780 cloudMediaRetainType == CloudMediaRetainType::HDC_RETAIN_FORCE) {
1781 ret = MediaAssetsService::GetInstance().RetainCloudMediaAsset(cloudMediaRetainType);
1782 } else {
1783 ret = E_INVALID_VALUES;
1784 MEDIA_ERR_LOG("RetainCloudMediaAsset error, err type: %{public}d", reqBody.cloudMediaRetainType);
1785 }
1786 MEDIA_INFO_LOG("RetainCloudMediaAsset end, ret:%{public}d", ret);
1787 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1788 }
1789
GrantPhotoUriPermission(MessageParcel & data,MessageParcel & reply)1790 int32_t MediaAssetsControllerService::GrantPhotoUriPermission(MessageParcel &data, MessageParcel &reply)
1791 {
1792 MEDIA_INFO_LOG("enter GrantPhotoUriPermission");
1793 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GRANT_PHOTO_URI_PERMISSION);
1794 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1795 DfxTimer dfxTimer(operationCode, timeout, true);
1796 GrantUriPermissionReqBody reqBody;
1797
1798 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1799 if (ret != E_OK) {
1800 MEDIA_ERR_LOG("GrantPhotoUriPermission Read Request Error");
1801 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1802 }
1803 GrantUriPermissionDto grantUriPermDto;
1804 grantUriPermDto.tokenId = reqBody.tokenId;
1805 grantUriPermDto.srcTokenId = reqBody.srcTokenId;
1806 grantUriPermDto.fileId = reqBody.fileId;
1807 grantUriPermDto.permissionType = reqBody.permissionType;
1808 grantUriPermDto.hideSensitiveType = reqBody.hideSensitiveType;
1809 grantUriPermDto.uriType = reqBody.uriType;
1810
1811 ret = MediaAssetsService::GetInstance().GrantPhotoUriPermission(grantUriPermDto);
1812 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1813 }
1814
GrantPhotoUrisPermission(MessageParcel & data,MessageParcel & reply)1815 int32_t MediaAssetsControllerService::GrantPhotoUrisPermission(MessageParcel &data, MessageParcel &reply)
1816 {
1817 MEDIA_INFO_LOG("enter GrantPhotoUrisPermission");
1818 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_GRANT_PHOTO_URIS_PERMISSION);
1819 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1820 DfxTimer dfxTimer(operationCode, timeout, true);
1821 GrantUrisPermissionReqBody reqBody;
1822
1823 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1824 if (ret != E_OK) {
1825 MEDIA_ERR_LOG("GrantPhotoUrisPermission Read Request Error");
1826 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1827 }
1828 GrantUrisPermissionDto grantUrisPermDto;
1829 grantUrisPermDto.tokenId = reqBody.tokenId;
1830 grantUrisPermDto.srcTokenId = reqBody.srcTokenId;
1831 grantUrisPermDto.fileIds.assign(reqBody.fileIds.begin(), reqBody.fileIds.end());
1832 grantUrisPermDto.permissionType = reqBody.permissionType;
1833 grantUrisPermDto.hideSensitiveType = reqBody.hideSensitiveType;
1834 grantUrisPermDto.uriType = reqBody.uriType;
1835
1836 ret = MediaAssetsService::GetInstance().GrantPhotoUrisPermission(grantUrisPermDto);
1837 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1838 }
1839
CheckUriPermissionInner(MessageParcel & data,MessageParcel & reply)1840 int32_t MediaAssetsControllerService::CheckUriPermissionInner(MessageParcel &data, MessageParcel &reply)
1841 {
1842 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CHECK_PHOTO_URI_PERMISSION);
1843 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1844 DfxTimer dfxTimer(operationCode, timeout, true);
1845 CheckUriPermissionInnerReqBody reqBody;
1846 CheckUriPermissionInnerRespBody respBody;
1847 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1848 if (ret != E_OK) {
1849 MEDIA_ERR_LOG("CheckUriPermissionInner Read Request Error");
1850 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1851 }
1852 CheckUriPermissionInnerDto dto;
1853 reqBody.Convert2Dto(dto);
1854 ret = MediaAssetsService::GetInstance().CheckPhotoUriPermissionInner(dto);
1855 if (ret == E_OK) {
1856 respBody.InitByDto(dto);
1857 }
1858 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1859 }
1860
CancelPhotoUriPermission(MessageParcel & data,MessageParcel & reply)1861 int32_t MediaAssetsControllerService::CancelPhotoUriPermission(MessageParcel &data, MessageParcel &reply)
1862 {
1863 MEDIA_INFO_LOG("enter GrantPhotoUriPermission");
1864 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_CANCEL_PHOTO_URI_PERMISSION);
1865 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1866 DfxTimer dfxTimer(operationCode, timeout, true);
1867 CancelUriPermissionReqBody reqBody;
1868
1869 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1870 if (ret != E_OK) {
1871 MEDIA_ERR_LOG("CancelPhotoUriPermission Read Request Error");
1872 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1873 }
1874 CancelUriPermissionDto cancelUriPermDto;
1875 cancelUriPermDto.tokenId = reqBody.tokenId;
1876 cancelUriPermDto.srcTokenId = reqBody.srcTokenId;
1877 cancelUriPermDto.fileId = reqBody.fileId;
1878 cancelUriPermDto.permissionType = reqBody.permissionType;
1879
1880 cancelUriPermDto.uriType = reqBody.uriType;
1881
1882 ret = MediaAssetsService::GetInstance().CancelPhotoUriPermission(cancelUriPermDto);
1883 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1884 }
1885
CancelPhotoUriPermissionInner(MessageParcel & data,MessageParcel & reply)1886 int32_t MediaAssetsControllerService::CancelPhotoUriPermissionInner(MessageParcel &data, MessageParcel &reply)
1887 {
1888 MEDIA_INFO_LOG("enter CancelPhotoUriPermissionInner");
1889 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::ASSET_CHANGE_CREATE_ASSET);
1890 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1891 DfxTimer dfxTimer(operationCode, timeout, true);
1892 CancelUriPermissionInnerReqBody reqBody;
1893
1894 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1895 if (ret != E_OK) {
1896 MEDIA_ERR_LOG("CancelPhotoUriPermissionInner Read Request Error");
1897 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1898 }
1899 CancelUriPermissionInnerDto cancelUriPermInnerDto;
1900 cancelUriPermInnerDto.targetTokenId = reqBody.targetTokenId;
1901 cancelUriPermInnerDto.srcTokenId = reqBody.srcTokenId;
1902 cancelUriPermInnerDto.fileIds = reqBody.fileIds;
1903 cancelUriPermInnerDto.uriTypes = reqBody.uriTypes;
1904 cancelUriPermInnerDto.permissionTypes = reqBody.permissionTypes;
1905 ret = MediaAssetsService::GetInstance().CancelPhotoUriPermissionInner(cancelUriPermInnerDto);
1906 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1907 }
1908
StartThumbnailCreationTask(MessageParcel & data,MessageParcel & reply)1909 int32_t MediaAssetsControllerService::StartThumbnailCreationTask(MessageParcel &data, MessageParcel &reply)
1910 {
1911 MEDIA_INFO_LOG("enter StartThumbnailCreationTask");
1912 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_START_THUMBNAIL_CREATION_TASK);
1913 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1914 DfxTimer dfxTimer(operationCode, timeout, true);
1915 StartThumbnailCreationTaskReqBody reqBody;
1916
1917 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1918 if (ret != E_OK) {
1919 MEDIA_ERR_LOG("StartThumbnailCreationTask Read Request Error");
1920 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1921 }
1922 StartThumbnailCreationTaskDto startCreationTaskDto;
1923 startCreationTaskDto.predicates = reqBody.predicates;
1924 startCreationTaskDto.requestId = reqBody.requestId;
1925 ret = MediaAssetsService::GetInstance().StartThumbnailCreationTask(startCreationTaskDto);
1926 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1927 }
1928
StopThumbnailCreationTask(MessageParcel & data,MessageParcel & reply)1929 int32_t MediaAssetsControllerService::StopThumbnailCreationTask(MessageParcel &data, MessageParcel &reply)
1930 {
1931 MEDIA_INFO_LOG("enter StopThumbnailCreationTask");
1932 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_STOP_THUMBNAIL_CREATION_TASK);
1933 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1934 DfxTimer dfxTimer(operationCode, timeout, true);
1935 StopThumbnailCreationTaskReqBody reqBody;
1936
1937 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1938 if (ret != E_OK) {
1939 MEDIA_ERR_LOG("StopThumbnailCreationTask Read Request Error");
1940 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1941 }
1942 StopThumbnailCreationTaskDto stopCreationTaskDto;
1943 stopCreationTaskDto.requestId = reqBody.requestId;
1944 ret = MediaAssetsService::GetInstance().StopThumbnailCreationTask(stopCreationTaskDto);
1945 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1946 }
1947
IsEdited(MessageParcel & data,MessageParcel & reply)1948 int32_t MediaAssetsControllerService::IsEdited(MessageParcel &data, MessageParcel &reply)
1949 {
1950 MEDIA_INFO_LOG("enter IsEdited");
1951 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_IS_EDITED);
1952 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1953 DfxTimer dfxTimer(operationCode, timeout, true);
1954 IsEditedReqBody reqBody;
1955 IsEditedRespBody respBody;
1956 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1957 if (ret != E_OK) {
1958 MEDIA_ERR_LOG("IsEdited Read Request Error");
1959 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1960 }
1961
1962 IsEditedDto dto;
1963 dto.fileId = reqBody.fileId;
1964 ret = MediaAssetsService::GetInstance().IsEdited(dto, respBody);
1965 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1966 }
1967
RequestEditData(MessageParcel & data,MessageParcel & reply)1968 int32_t MediaAssetsControllerService::RequestEditData(MessageParcel &data, MessageParcel &reply)
1969 {
1970 MEDIA_INFO_LOG("enter RequestEditData");
1971 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_REQUEST_EDIT_DATA);
1972 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1973 DfxTimer dfxTimer(operationCode, timeout, true);
1974 RequestEditDataReqBody reqBody;
1975 RequestEditDataRespBody respBody;
1976 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1977 if (ret != E_OK) {
1978 MEDIA_ERR_LOG("RequestEditData Read Request Error");
1979 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
1980 }
1981
1982 RequestEditDataDto dto;
1983 dto.predicates = reqBody.predicates;
1984 ret = MediaAssetsService::GetInstance().RequestEditData(dto, respBody);
1985 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
1986 }
1987
GetEditData(MessageParcel & data,MessageParcel & reply)1988 int32_t MediaAssetsControllerService::GetEditData(MessageParcel &data, MessageParcel &reply)
1989 {
1990 MEDIA_INFO_LOG("enter GetEditData");
1991 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_GET_EDIT_DATA);
1992 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
1993 DfxTimer dfxTimer(operationCode, timeout, true);
1994 GetEditDataReqBody reqBody;
1995 GetEditDataRespBody respBody;
1996 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
1997 if (ret != E_OK) {
1998 MEDIA_ERR_LOG("GetEditData Read Request Error");
1999 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2000 }
2001
2002 GetEditDataDto dto;
2003 dto.predicates = reqBody.predicates;
2004 ret = MediaAssetsService::GetInstance().GetEditData(dto, respBody);
2005 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2006 }
2007
GetCloudMediaAssetStatus(MessageParcel & data,MessageParcel & reply)2008 int32_t MediaAssetsControllerService::GetCloudMediaAssetStatus(MessageParcel &data, MessageParcel &reply)
2009 {
2010 MEDIA_INFO_LOG("enter GetCloudMediaAssetStatus");
2011 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_GET_CLOUDMEDIA_ASSET_STATUS);
2012 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2013 DfxTimer dfxTimer(operationCode, timeout, true);
2014 GetCloudMediaAssetStatusReqBody reqBody;
2015 GetCloudMediaAssetStatusReqBody respBody;
2016 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2017 if (ret != E_OK) {
2018 MEDIA_ERR_LOG("GetCloudMediaAssetStatus Read Request Error");
2019 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2020 }
2021
2022 ret = MediaAssetsService::GetInstance().GetCloudMediaAssetStatus(respBody.status);
2023 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2024 }
2025
StartAssetAnalysis(MessageParcel & data,MessageParcel & reply)2026 int32_t MediaAssetsControllerService::StartAssetAnalysis(MessageParcel &data, MessageParcel &reply)
2027 {
2028 MEDIA_INFO_LOG("enter StartAssetAnalysis");
2029 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_START_ASSET_ANALYSIS);
2030 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2031 DfxTimer dfxTimer(operationCode, timeout, true);
2032 StartAssetAnalysisReqBody reqBody;
2033 StartAssetAnalysisRespBody respBody;
2034 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2035 if (ret != E_OK) {
2036 MEDIA_ERR_LOG("StartAssetAnalysis Read Request Error");
2037 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2038 }
2039 StartAssetAnalysisDto dto;
2040 dto.uri = reqBody.uri;
2041 dto.predicates = reqBody.predicates;
2042 ret = MediaAssetsService::GetInstance().StartAssetAnalysis(dto, respBody);
2043 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2044 }
2045
RequestContent(MessageParcel & data,MessageParcel & reply)2046 int32_t MediaAssetsControllerService::RequestContent(MessageParcel &data, MessageParcel &reply)
2047 {
2048 MEDIA_INFO_LOG("enter RequestContent");
2049 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::PAH_REQUEST_CONTENT);
2050 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2051 DfxTimer dfxTimer(operationCode, timeout, true);
2052 RequestContentReqBody reqBody;
2053 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2054 if (ret != E_OK) {
2055 MEDIA_ERR_LOG("RequestContent Read Request Error");
2056 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2057 }
2058
2059 int32_t position = 0;
2060 RequestContentRespBody respBody;
2061
2062 ret = MediaAssetsService::GetInstance().RequestContent(reqBody.mediaId, position);
2063 respBody.position = position;
2064 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2065 }
2066
GetCloudEnhancementPair(MessageParcel & data,MessageParcel & reply)2067 int32_t MediaAssetsControllerService::GetCloudEnhancementPair(MessageParcel &data, MessageParcel &reply)
2068 {
2069 MEDIA_INFO_LOG("enter GetCloudEnhancementPair");
2070 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::GET_CLOUD_ENHANCEMENT_PAIR);
2071 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2072 DfxTimer dfxTimer(operationCode, timeout, true);
2073 GetCloudEnhancementPairReqBody reqBody;
2074 GetCloudEnhancementPairRespBody respBody;
2075
2076 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2077 if (ret != E_OK) {
2078 MEDIA_ERR_LOG("GetCloudEnhancementPair Read Request Error");
2079 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2080 }
2081
2082 GetCloudEnhancementPairDto dto;
2083 dto.photoUri = reqBody.photoUri;
2084 ret = MediaAssetsService::GetInstance().GetCloudEnhancementPair(dto, respBody);
2085 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2086 }
2087
QueryCloudEnhancementTaskState(MessageParcel & data,MessageParcel & reply)2088 int32_t MediaAssetsControllerService::QueryCloudEnhancementTaskState(MessageParcel &data, MessageParcel &reply)
2089 {
2090 MEDIA_INFO_LOG("enter QueryCloudEnhancementTaskState");
2091 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_CLOUD_ENHANCEMENT_TASK_STATE);
2092 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2093 DfxTimer dfxTimer(operationCode, timeout, true);
2094 QueryCloudEnhancementTaskStateReqBody reqBody;
2095 QueryCloudEnhancementTaskStateRespBody respBody;
2096
2097 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2098 if (ret != E_OK) {
2099 MEDIA_ERR_LOG("QueryCloudEnhancementTaskState Read Request Error");
2100 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2101 }
2102
2103 QueryCloudEnhancementTaskStateDto dto;
2104 ret = MediaAssetsService::GetInstance().QueryCloudEnhancementTaskState(reqBody.photoUri, dto);
2105 respBody.fileId = dto.fileId;
2106 respBody.photoId = dto.photoId;
2107 respBody.ceAvailable = dto.ceAvailable;
2108 respBody.ceErrorCode = dto.ceErrorCode;
2109 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2110 }
2111
SyncCloudEnhancementTaskStatus(MessageParcel & data,MessageParcel & reply)2112 int32_t MediaAssetsControllerService::SyncCloudEnhancementTaskStatus(MessageParcel &data, MessageParcel &reply)
2113 {
2114 MEDIA_INFO_LOG("enter SyncCloudEnhancementTaskStatus");
2115 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::SYNC_CLOUD_ENHANCEMENT_TASK_STATUS);
2116 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2117 DfxTimer dfxTimer(operationCode, timeout, true);
2118 CloudEnhancementReqBody reqBody;
2119 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2120 if (ret != E_OK) {
2121 MEDIA_ERR_LOG("SyncCloudEnhancementTaskStatus Read Request Error");
2122 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2123 }
2124 if (ret == E_OK) {
2125 ret = MediaAssetsService::GetInstance().SyncCloudEnhancementTaskStatus();
2126 }
2127 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2128 }
2129
QueryPhotoStatus(MessageParcel & data,MessageParcel & reply)2130 int32_t MediaAssetsControllerService::QueryPhotoStatus(MessageParcel &data, MessageParcel &reply)
2131 {
2132 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::QUERY_PHOTO_STATUS);
2133 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2134 DfxTimer dfxTimer(operationCode, timeout, true);
2135 QueryPhotoReqBody reqBody;
2136 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2137 if (ret != E_OK) {
2138 MEDIA_ERR_LOG("QueryPhotoStatus Read Request Error");
2139 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2140 }
2141 QueryPhotoRespBody respBody;
2142 ret = MediaAssetsService::GetInstance().QueryPhotoStatus(reqBody, respBody);
2143 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2144 }
2145
LogMovingPhoto(MessageParcel & data,MessageParcel & reply)2146 int32_t MediaAssetsControllerService::LogMovingPhoto(MessageParcel &data, MessageParcel &reply)
2147 {
2148 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::LOG_MOVING_PHOTO);
2149 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2150 DfxTimer dfxTimer(operationCode, timeout, true);
2151 AdaptedReqBody reqBody;
2152 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2153 if (ret != E_OK) {
2154 MEDIA_ERR_LOG("LogMovingPhoto Read Request Error");
2155 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2156 }
2157 ret = MediaAssetsService::GetInstance().LogMovingPhoto(reqBody);
2158 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2159 }
2160
GetResultSetFromDb(MessageParcel & data,MessageParcel & reply)2161 int32_t MediaAssetsControllerService::GetResultSetFromDb(MessageParcel &data, MessageParcel &reply)
2162 {
2163 MEDIA_INFO_LOG("enter GetResultSetFromDb");
2164 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_RESULT_SET_FROM_DB);
2165 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2166 DfxTimer dfxTimer(operationCode, timeout, true);
2167 GetResultSetFromDbReqBody reqBody;
2168 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2169 if (ret != E_OK) {
2170 MEDIA_ERR_LOG("GetResultSetFromDb Read Request Error");
2171 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2172 }
2173
2174 GetResultSetFromDbDto getResultSetFromDbDto;
2175 getResultSetFromDbDto.columnName = reqBody.columnName;
2176 getResultSetFromDbDto.value = reqBody.value;
2177 getResultSetFromDbDto.columns = reqBody.columns;
2178 GetResultSetFromDbRespBody respBody;
2179 ret = MediaAssetsService::GetInstance().GetResultSetFromDb(getResultSetFromDbDto, respBody);
2180 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2181 }
2182
GetResultSetFromPhotosExtend(MessageParcel & data,MessageParcel & reply)2183 int32_t MediaAssetsControllerService::GetResultSetFromPhotosExtend(MessageParcel &data, MessageParcel &reply)
2184 {
2185 MEDIA_INFO_LOG("enter GetResultSetFromPhotosExtend");
2186 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_RESULT_SET_FROM_PHOTOS);
2187 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2188 DfxTimer dfxTimer(operationCode, timeout, true);
2189 GetResultSetFromPhotosExtendReqBody reqBody;
2190 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2191 if (ret != E_OK) {
2192 MEDIA_ERR_LOG("GetResultSetFromPhotosExtend Read Request Error");
2193 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2194 }
2195
2196 if (!ParameterUtils::CheckPhotoUri(reqBody.value)) {
2197 MEDIA_ERR_LOG("Failed to check invalid uri: %{public}s", reqBody.value.c_str());
2198 return IPC::UserDefineIPC().WriteResponseBody(reply, E_INVALID_VALUES);
2199 }
2200
2201 GetResultSetFromPhotosExtendRespBody respBody;
2202 ret = MediaAssetsService::GetInstance().GetResultSetFromPhotosExtend(reqBody.value, reqBody.columns, respBody);
2203 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2204 }
2205
GetMovingPhotoDateModified(MessageParcel & data,MessageParcel & reply)2206 int32_t MediaAssetsControllerService::GetMovingPhotoDateModified(MessageParcel &data, MessageParcel &reply)
2207 {
2208 MEDIA_INFO_LOG("enter GetMovingPhotoDateModified");
2209 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_MOVING_PHOTO_DATE_MODIFIED);
2210 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2211 DfxTimer dfxTimer(operationCode, timeout, true);
2212 GetMovingPhotoDateModifiedReqBody reqBody;
2213 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2214 if (ret != E_OK) {
2215 MEDIA_ERR_LOG("GetMovingPhotoDateModified Read Request Error");
2216 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2217 }
2218
2219 GetMovingPhotoDateModifiedRespBody respBody;
2220 ret = MediaAssetsService::GetInstance().GetMovingPhotoDateModified(reqBody.fileId, respBody);
2221 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2222 }
GetFilePathFromUri(MessageParcel & data,MessageParcel & reply)2223 int32_t MediaAssetsControllerService::GetFilePathFromUri(MessageParcel &data, MessageParcel &reply)
2224 {
2225 MEDIA_INFO_LOG("enter GetFilePathFromUri");
2226 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_FILEPATH_FROM_URI);
2227 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2228 DfxTimer dfxTimer(operationCode, timeout, true);
2229 GetFilePathFromUriReqBody reqBody;
2230 GetFilePathFromUriRespBody respBody;
2231
2232 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2233 if (ret != E_OK) {
2234 MEDIA_ERR_LOG("GetFilePathFromUri Read Request Error");
2235 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2236 }
2237
2238 ret = MediaAssetsService::GetInstance().GetFilePathFromUri(reqBody.virtualId, respBody);
2239 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2240 }
2241
GetUriFromFilePath(MessageParcel & data,MessageParcel & reply)2242 int32_t MediaAssetsControllerService::GetUriFromFilePath(MessageParcel &data, MessageParcel &reply)
2243 {
2244 MEDIA_INFO_LOG("enter GetUriFromFilePath");
2245 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_URI_FROM_FILEPATH);
2246 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2247 DfxTimer dfxTimer(operationCode, timeout, true);
2248 GetUriFromFilePathReqBody reqBody;
2249 GetUriFromFilePathRespBody respBody;
2250
2251 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2252 if (ret != E_OK) {
2253 MEDIA_ERR_LOG("GetUriFromFilePath Read Request Error");
2254 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2255 }
2256
2257 ret = MediaAssetsService::GetInstance().GetUriFromFilePath(reqBody.tempPath, respBody);
2258 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2259 }
2260
CloseAsset(MessageParcel & data,MessageParcel & reply)2261 int32_t MediaAssetsControllerService::CloseAsset(MessageParcel &data, MessageParcel &reply)
2262 {
2263 MEDIA_INFO_LOG("enter CloseAsset");
2264 CloseAssetReqBody reqBody;
2265 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2266 if (ret != E_OK) {
2267 MEDIA_ERR_LOG("CloseAsset Read Request Error");
2268 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2269 }
2270 ret = MediaAssetsService::GetInstance().CloseAsset(reqBody);
2271 MEDIA_INFO_LOG("CloseAsset ret=%{public}d", ret);
2272 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2273 }
2274
GetUrisByOldUrisInner(MessageParcel & data,MessageParcel & reply)2275 int32_t MediaAssetsControllerService::GetUrisByOldUrisInner(MessageParcel &data, MessageParcel &reply)
2276 {
2277 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_GET_URIS_BY_OLD_URIS);
2278 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2279 DfxTimer dfxTimer(operationCode, timeout, true);
2280 GetUrisByOldUrisInnerReqBody reqBody;
2281 GetUrisByOldUrisInnerRespBody respBody;
2282 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2283 if (ret != E_OK) {
2284 MEDIA_ERR_LOG("GetUrisByOldUrisInner Read Request Error");
2285 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2286 }
2287 GetUrisByOldUrisInnerDto dto;
2288 reqBody.Convert2Dto(dto);
2289 ret = MediaAssetsService::GetInstance().GetUrisByOldUrisInner(dto);
2290 if (ret == E_OK) {
2291 respBody.InitByDto(dto);
2292 }
2293 return IPC::UserDefineIPC().WriteResponseBody(reply, respBody, ret);
2294 }
2295
Restore(MessageParcel & data,MessageParcel & reply)2296 int32_t MediaAssetsControllerService::Restore(MessageParcel &data, MessageParcel &reply)
2297 {
2298 MEDIA_INFO_LOG("enter Restore");
2299 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CUSTOM_RESTORE);
2300 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2301 DfxTimer dfxTimer(operationCode, timeout, true);
2302 RestoreReqBody reqBody;
2303
2304 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2305 if (ret != E_OK) {
2306 MEDIA_ERR_LOG("Restore Read Request Error");
2307 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2308 }
2309
2310 ret = ParameterUtils::CheckRestore(reqBody);
2311 if (ret != E_OK) {
2312 MEDIA_ERR_LOG("params is invalid");
2313 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2314 }
2315 auto dto = RestoreDto::Create(reqBody);
2316 ret = MediaAssetsService::GetInstance().Restore(dto);
2317 CHECK_AND_PRINT_LOG(ret == E_OK, "Restore failed");
2318 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2319 }
2320
StopRestore(MessageParcel & data,MessageParcel & reply)2321 int32_t MediaAssetsControllerService::StopRestore(MessageParcel &data, MessageParcel &reply)
2322 {
2323 MEDIA_INFO_LOG("enter StopRestore");
2324 uint32_t operationCode = static_cast<uint32_t>(MediaLibraryBusinessCode::INNER_CUSTOM_RESTORE_CANCEL);
2325 int64_t timeout = DfxTimer::GetOperationCodeTimeout(operationCode);
2326 DfxTimer dfxTimer(operationCode, timeout, true);
2327 StopRestoreReqBody reqBody;
2328
2329 int32_t ret = IPC::UserDefineIPC().ReadRequestBody(data, reqBody);
2330 if (ret != E_OK) {
2331 MEDIA_ERR_LOG("StopRestore Read Request Error");
2332 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2333 }
2334
2335 if (reqBody.keyPath.empty()) {
2336 MEDIA_ERR_LOG("params is invalid");
2337 return IPC::UserDefineIPC().WriteResponseBody(reply, E_INVALID_VALUES);
2338 }
2339 ret = MediaAssetsService::GetInstance().StopRestore(reqBody.keyPath);
2340 CHECK_AND_PRINT_LOG(ret == E_OK, "StopRestore failed");
2341 return IPC::UserDefineIPC().WriteResponseBody(reply, ret);
2342 }
2343 } // namespace OHOS::Media