1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define MLOG_TAG "Media_Client"
16
17 #include "cloud_media_photo_handler.h"
18
19 #include <string>
20
21 #include "cloud_file_data_convert.h"
22 #include "cloud_media_operation_code.h"
23 #include "cloud_mdkrecord_photos_vo.h"
24 #include "get_retey_records_vo.h"
25 #include "medialibrary_errno.h"
26 #include "media_log.h"
27 #include "media_req_vo.h"
28 #include "media_resp_vo.h"
29 #include "mdk_record_photos_data.h"
30 #include "on_copy_records_photos_vo.h"
31 #include "on_create_records_photos_vo.h"
32 #include "on_delete_records_photos_vo.h"
33 #include "on_modify_records_photos_vo.h"
34 #include "on_dentry_file_vo.h"
35 #include "on_fetch_records_vo.h"
36 #include "on_fetch_photos_vo.h"
37 #include "user_define_ipc_client.h"
38 #include "failed_size_resp_vo.h"
39 #include "get_check_records_vo.h"
40
41 namespace OHOS::Media::CloudSync {
SetUserId(const int32_t & userId)42 void CloudMediaPhotoHandler::SetUserId(const int32_t &userId)
43 {
44 this->userId_ = userId;
45 }
46
SetTraceId(const std::string & traceId)47 void CloudMediaPhotoHandler::SetTraceId(const std::string &traceId)
48 {
49 this->traceId_ = traceId;
50 }
51
GetTraceId() const52 std::string CloudMediaPhotoHandler::GetTraceId() const
53 {
54 return this->traceId_;
55 }
56
57 /**
58 * stats: 引用入参，按照以下顺序进行返回 [新增，合一，元数据修改，文件修改，删除]:
59 * stats: [100, 30, 50, 10, 10]
60 */
OnFetchRecords(const std::vector<MDKRecord> & records,std::vector<CloudMetaData> & newData,std::vector<CloudMetaData> & fdirtyData,std::vector<std::string> & failedRecords,std::vector<int32_t> & stats)61 int32_t CloudMediaPhotoHandler::OnFetchRecords(const std::vector<MDKRecord> &records,
62 std::vector<CloudMetaData> &newData, std::vector<CloudMetaData> &fdirtyData,
63 std::vector<std::string> &failedRecords, std::vector<int32_t> &stats)
64 {
65 MEDIA_INFO_LOG("OnFetchRecords, size: %{public}zu", records.size());
66 CHECK_AND_RETURN_RET_LOG(!records.empty(), E_OK, "OnFetchRecords records is empty");
67 int32_t ret;
68 OnFetchRecordsReqBody reqBody;
69 OnFetchRecordsRespBody respBody;
70 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
71 for (auto record : records) {
72 OnFetchPhotosVo onFetchPhotoVo;
73 if (dataConvertor.ConverMDKRecordToOnFetchPhotosVo(record, onFetchPhotoVo) != E_OK) {
74 MEDIA_ERR_LOG("OnFetchRecords ConverMDKRecordToOnFetchPhotosVo error, recordId: %{public}s",
75 record.GetRecordId().c_str());
76 continue;
77 }
78 MEDIA_INFO_LOG("OnFetchRecords OnFetchPhotoVo: %{public}s", onFetchPhotoVo.ToString().c_str());
79 reqBody.AddOnFetchPhotoData(onFetchPhotoVo);
80 }
81 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_FETCH_RECORDS);
82 ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
83 respBody);
84 failedRecords = respBody.failedRecords;
85 stats = respBody.stats;
86 newData = this->processor_.GetCloudNewData(respBody.newDatas);
87 MEDIA_INFO_LOG("OnFetchRecords NewDataBody: %{public}s", respBody.ToString().c_str());
88 fdirtyData = this->processor_.GetCloudFdirtyData(respBody.fdirtyDatas);
89 return ret;
90 }
91
OnDentryFileInsert(std::vector<MDKRecord> & records,std::vector<std::string> & failedRecords)92 int32_t CloudMediaPhotoHandler::OnDentryFileInsert(
93 std::vector<MDKRecord> &records, std::vector<std::string> &failedRecords)
94 {
95 MEDIA_INFO_LOG("OnDentryFileInsert, size: %{public}zu", records.size());
96 CHECK_AND_RETURN_RET_LOG(!records.empty(), E_OK, "OnDentryFileInsert records is empty");
97 int32_t ret;
98 OnDentryFileReqBody reqBody;
99 OnDentryFileRespBody respBody;
100 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
101 for (auto record : records) {
102 OnFetchPhotosVo onDentryRecord;
103 if (dataConvertor.ConverMDKRecordToOnFetchPhotosVo(record, onDentryRecord) != E_OK) {
104 MEDIA_ERR_LOG("OnDentryFileInsert ConverMDKRecordToOnFetchPhotosVo error");
105 continue;
106 }
107 MEDIA_INFO_LOG("OnDentryFileInsert OnFetchPhotosVo: %{public}s", onDentryRecord.ToString().c_str());
108 reqBody.AddOnDentryFileRecord(onDentryRecord);
109 }
110 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_DENTRY_FILE_INSERT);
111 ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
112 respBody);
113 failedRecords = respBody.failedRecords;
114 MEDIA_INFO_LOG("OnDentryFileInsert end");
115 return ret;
116 }
117
GetRetryRecords(std::vector<std::string> & records)118 int32_t CloudMediaPhotoHandler::GetRetryRecords(std::vector<std::string> &records)
119 {
120 MEDIA_INFO_LOG("enter CloudMediaPhotoHandler::GetRetryRecords");
121 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_RETRY_RECORDS);
122 GetRetryRecordsRespBody respBody;
123 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Get(operationCode,
124 respBody);
125 records = respBody.cloudIds;
126 return ret;
127 }
128
GetCheckRecords(const std::vector<std::string> & cloudIds,std::unordered_map<std::string,CloudCheckData> & checkRecords)129 int32_t CloudMediaPhotoHandler::GetCheckRecords(
130 const std::vector<std::string> &cloudIds, std::unordered_map<std::string, CloudCheckData> &checkRecords)
131 {
132 MEDIA_INFO_LOG("enter CloudMediaPhotoHandler::GetCheckRecords %{public}zu", cloudIds.size());
133 CHECK_AND_RETURN_RET_LOG(!cloudIds.empty(), E_OK, "GetCheckRecords cloudIds is empty");
134 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_CHECK_RECORDS);
135 GetCheckRecordsReqBody reqBody;
136 reqBody.cloudIds = cloudIds;
137 GetCheckRecordsRespBody respBody;
138 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
139 respBody);
140 if (ret != E_OK) {
141 MEDIA_ERR_LOG("Failed to GetCheckRecords");
142 return ret;
143 }
144 MEDIA_INFO_LOG("GetCheckRecords GetCheckRecordsRespBody: %{public}s", respBody.ToString().c_str());
145 checkRecords.clear();
146 for (auto &[cloudId, info] : respBody.checkDataList) {
147 CloudCheckData cloudCheckData;
148 cloudCheckData.cloudId = cloudId;
149 cloudCheckData.size = info.size;
150 cloudCheckData.path = info.data;
151 cloudCheckData.fileName = info.fileName;
152 cloudCheckData.type = info.mediaType;
153 cloudCheckData.version = info.cloudVersion;
154 cloudCheckData.position = info.position;
155 cloudCheckData.modifiedTime = info.dateModified;
156 cloudCheckData.dirtyType = info.dirty;
157 cloudCheckData.syncStatus = info.syncStatus;
158 cloudCheckData.thmStatus = info.thmStatus;
159 for (auto &[key, value] : info.attachment) {
160 CloudFileData fileData;
161 fileData.fileName = value.fileName;
162 fileData.filePath = value.filePath;
163 fileData.size = value.size;
164 cloudCheckData.attachment[key] = fileData;
165 }
166 checkRecords[cloudId] = cloudCheckData;
167 MEDIA_INFO_LOG("GetCheckRecords CloudCheckData: %{public}s", cloudCheckData.ToString().c_str());
168 }
169 return E_OK;
170 }
171
GetCreatedRecords(std::vector<MDKRecord> & records,int32_t size)172 int32_t CloudMediaPhotoHandler::GetCreatedRecords(std::vector<MDKRecord> &records, int32_t size)
173 {
174 MEDIA_INFO_LOG("CloudMediaPhotoHandler::GetCreatedRecords %{public}d", size);
175 CloudMdkRecordPhotosReqBody reqBody;
176 reqBody.size = size;
177 CloudMdkRecordPhotosRespBody respBody;
178 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_CREATED_RECORDS);
179 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
180 respBody);
181 if (ret != E_OK) {
182 MEDIA_ERR_LOG("GetCreatedRecords fail to call service function");
183 return ret;
184 }
185 std::vector<CloudMdkRecordPhotosVo> createdRecords = respBody.GetPhotosRecords();
186 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_CREATE, userId_};
187 for (auto &record : createdRecords) {
188 MDKRecord dkRecord;
189 ret = dataConvertor.ConvertToMdkRecord(record, dkRecord);
190 if (ret == E_OK) {
191 records.push_back(dkRecord);
192 } else {
193 MEDIA_ERR_LOG("GetCreatedRecords ReportFailure, ret: %{public}d, photosVo: %{public}s",
194 ret,
195 record.ToString().c_str());
196 this->ReportFailure(
197 ReportFailureReqBody()
198 .SetApiCode(static_cast<int32_t>(CloudMediaPhotoOperationCode::CMD_GET_CREATED_RECORDS))
199 .SetErrorCode(ret)
200 .SetFileId(record.fileId)
201 .SetCloudId(record.cloudId));
202 }
203 }
204 return E_OK;
205 }
206
GetMetaModifiedRecords(std::vector<MDKRecord> & records,int32_t size,int32_t dirtyType)207 int32_t CloudMediaPhotoHandler::GetMetaModifiedRecords(std::vector<MDKRecord> &records, int32_t size, int32_t dirtyType)
208 {
209 CloudMdkRecordPhotosReqBody reqBody;
210 reqBody.size = size;
211 reqBody.dirtyType = dirtyType;
212 CloudMdkRecordPhotosRespBody respBody;
213 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_META_MODIFIED_RECORDS);
214 int32_t ret =
215 IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody, respBody);
216 if (ret != E_OK) {
217 MEDIA_ERR_LOG("CloudMediaPhotoHandler::GetMetaModifiedRecords Call IPC Error");
218 return ret;
219 }
220 std::vector<CloudMdkRecordPhotosVo> metaModifiedRecord = respBody.GetPhotosRecords();
221 MEDIA_INFO_LOG("Enter CloudMediaPhotoHandler::GetMetaModifiedRecords size: %{public}zu", metaModifiedRecord.size());
222 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_METADATA_MODIFY, userId_};
223 for (auto &record : metaModifiedRecord) {
224 MDKRecord dkRecord;
225 MEDIA_INFO_LOG("SetUpdateSourceAlbum CloudMdkRecordPhotosVo: %{public}s", record.ToString().c_str());
226 ret = dataConvertor.ConvertToMdkRecord(record, dkRecord);
227 MEDIA_INFO_LOG(
228 "Enter CloudMediaPhotoHandler::GetMetaModifiedRecords ConvertToMdkRecord: %{public}s, ret: %{public}d",
229 dkRecord.GetRecordId().c_str(),
230 ret);
231 if (ret == E_OK) {
232 records.push_back(dkRecord);
233 if (!record.removeAlbumCloudId.empty()) {
234 ret = dataConvertor.InsertAlbumIdChanges(dkRecord, records, record);
235 }
236 } else {
237 MEDIA_ERR_LOG("GetMetaModifiedRecords ReportFailure, ret: %{public}d, photosVo: %{public}s",
238 ret,
239 record.ToString().c_str());
240 this->ReportFailure(
241 ReportFailureReqBody()
242 .SetApiCode(static_cast<int32_t>(CloudMediaPhotoOperationCode::CMD_GET_META_MODIFIED_RECORDS))
243 .SetErrorCode(ret)
244 .SetFileId(record.fileId)
245 .SetCloudId(record.cloudId));
246 }
247 }
248 return E_OK;
249 }
250
GetFileModifiedRecords(std::vector<MDKRecord> & records,int32_t size)251 int32_t CloudMediaPhotoHandler::GetFileModifiedRecords(std::vector<MDKRecord> &records, int32_t size)
252 {
253 MEDIA_INFO_LOG("CloudMediaPhotoHandler::GetFileModifiedRecords");
254 CloudMdkRecordPhotosReqBody reqBody;
255 reqBody.size = size;
256 CloudMdkRecordPhotosRespBody respBody;
257 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_FILE_MODIFIED_RECORDS);
258 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
259 respBody);
260 if (ret != E_OK) {
261 MEDIA_ERR_LOG("GetFileModifiedRecords fail to call service function");
262 return ret;
263 }
264 std::vector<CloudMdkRecordPhotosVo> fileModifiedRecord = respBody.GetPhotosRecords();
265 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
266 for (auto &record : fileModifiedRecord) {
267 MDKRecord dkRecord;
268 ret = dataConvertor.ConvertToMdkRecord(record, dkRecord);
269 if (ret == E_OK) {
270 records.push_back(dkRecord);
271 if (!record.removeAlbumCloudId.empty()) {
272 ret = dataConvertor.InsertAlbumIdChanges(dkRecord, records, record);
273 }
274 } else {
275 MEDIA_ERR_LOG("GetFileModifiedRecords ReportFailure, ret: %{public}d, photosVo: %{public}s",
276 ret,
277 record.ToString().c_str());
278 this->ReportFailure(
279 ReportFailureReqBody()
280 .SetApiCode(static_cast<int32_t>(CloudMediaPhotoOperationCode::CMD_GET_FILE_MODIFIED_RECORDS))
281 .SetErrorCode(ret)
282 .SetFileId(record.fileId)
283 .SetCloudId(record.cloudId));
284 }
285 }
286 return E_OK;
287 }
288
GetDeletedRecords(std::vector<MDKRecord> & records,int32_t size)289 int32_t CloudMediaPhotoHandler::GetDeletedRecords(std::vector<MDKRecord> &records, int32_t size)
290 {
291 MEDIA_INFO_LOG("CloudSync test info %{public}d", size);
292 CloudMdkRecordPhotosReqBody reqBody;
293 reqBody.size = size;
294 CloudMdkRecordPhotosRespBody respBody;
295 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_DELETED_RECORDS);
296 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
297 respBody);
298 if (ret != E_OK) {
299 MEDIA_ERR_LOG("GetDeletedRecords fail to call service function");
300 return ret;
301 }
302 std::vector<CloudMdkRecordPhotosVo> deletedRecord = respBody.GetPhotosRecords();
303 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DELETE, userId_};
304 for (auto &record : deletedRecord) {
305 MDKRecord dkRecord;
306 ret = dataConvertor.ConvertToMdkRecord(record, dkRecord);
307 if (ret == E_OK) {
308 records.push_back(dkRecord);
309 } else {
310 MEDIA_ERR_LOG("GetDeletedRecords ReportFailure, ret: %{public}d, photosVo: %{public}s",
311 ret,
312 record.ToString().c_str());
313 this->ReportFailure(
314 ReportFailureReqBody()
315 .SetApiCode(static_cast<int32_t>(CloudMediaPhotoOperationCode::CMD_GET_DELETED_RECORDS))
316 .SetErrorCode(ret)
317 .SetFileId(record.fileId)
318 .SetCloudId(record.cloudId));
319 }
320 }
321 return E_OK;
322 }
323
GetCopyRecords(std::vector<MDKRecord> & records,int32_t size)324 int32_t CloudMediaPhotoHandler::GetCopyRecords(std::vector<MDKRecord> &records, int32_t size)
325 {
326 MEDIA_INFO_LOG("enter CloudMediaPhotoHandler::GetCopyRecords size:%{public}d", size);
327 CloudMdkRecordPhotosReqBody reqBody;
328 reqBody.size = size;
329 CloudMdkRecordPhotosRespBody respBody;
330 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_GET_COPY_RECORDS);
331 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
332 respBody);
333 if (ret != E_OK) {
334 MEDIA_ERR_LOG("GetCopyRecords fail to call service function");
335 return ret;
336 }
337 std::vector<CloudMdkRecordPhotosVo> copyRecord = respBody.GetPhotosRecords();
338 MEDIA_INFO_LOG("CloudMediaPhotoHandler::GetCopyRecords result count: %{public}zu", copyRecord.size());
339 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
340 for (auto &record : copyRecord) {
341 MDKRecord dkRecord;
342 ret = dataConvertor.ConvertToMdkRecord(record, dkRecord);
343 if (ret == E_OK) {
344 dkRecord.SetSrcRecordId(record.originalAssetCloudId);
345 records.push_back(dkRecord);
346 } else {
347 MEDIA_ERR_LOG(
348 "GetCopyRecords ReportFailure, ret: %{public}d, photosVo: %{public}s", ret, record.ToString().c_str());
349 this->ReportFailure(
350 ReportFailureReqBody()
351 .SetApiCode(static_cast<int32_t>(CloudMediaPhotoOperationCode::CMD_GET_COPY_RECORDS))
352 .SetErrorCode(ret)
353 .SetFileId(record.fileId)
354 .SetCloudId(record.cloudId));
355 }
356 }
357 return E_OK;
358 }
359
DeleteTempLivePhotoFile(std::string & livePhotoCachePath)360 void CloudMediaPhotoHandler::DeleteTempLivePhotoFile(std::string &livePhotoCachePath)
361 {
362 CHECK_AND_RETURN_LOG(!livePhotoCachePath.empty(), "livePhotoCachePath is empty");
363 int result = unlink(livePhotoCachePath.c_str());
364 CHECK_AND_RETURN_LOG(result == 0, "unlink err: %{public}d, result: %{public}d, livePhotoCachePath: %{public}s",
365 errno, result, livePhotoCachePath.c_str());
366 }
367
OnCreateRecords(const std::map<std::string,MDKRecordOperResult> & map,int32_t & failSize)368 int32_t CloudMediaPhotoHandler::OnCreateRecords(
369 const std::map<std::string, MDKRecordOperResult> &map, int32_t &failSize)
370 {
371 MEDIA_INFO_LOG("OnCreateRecords, size: %{public}zu", map.size());
372 CHECK_AND_RETURN_RET_LOG(!map.empty(), E_OK, "OnCreateRecords records is empty");
373 OnCreateRecordsPhotosReqBody req;
374 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_CREATE, userId_};
375 for (auto &entry : map) {
376 OnCreateRecord record;
377 if (dataConvertor.ConvertToOnCreateRecord(entry.first, entry.second, record) != E_OK) {
378 MEDIA_ERR_LOG("OnCreateRecords ConvertToOnCreateRecord error");
379 continue;
380 }
381 MEDIA_INFO_LOG("OnCreateRecords Record:%{public}s", record.ToString().c_str());
382 req.records.emplace_back(record);
383 DeleteTempLivePhotoFile(record.livePhotoCachePath);
384 }
385 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_CREATE_RECORDS);
386 FailedSizeResp resp;
387 resp.failedSize = 0;
388 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, req,
389 resp);
390 failSize = resp.failedSize;
391 MEDIA_INFO_LOG("OnCreateRecords Resp:%{public}s", resp.ToString().c_str());
392 return ret;
393 }
394
OnMdirtyRecords(const std::map<std::string,MDKRecordOperResult> & map,int32_t & failSize)395 int32_t CloudMediaPhotoHandler::OnMdirtyRecords(
396 const std::map<std::string, MDKRecordOperResult> &map, int32_t &failSize)
397 {
398 MEDIA_INFO_LOG("OnMdirtyRecords, size: %{public}zu", map.size());
399 CHECK_AND_RETURN_RET_LOG(!map.empty(), E_OK, "OnMdirtyRecords records is empty");
400 OnModifyRecordsPhotosReqBody req;
401 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
402 for (auto &entry : map) {
403 OnModifyRecord record;
404 if (dataConvertor.BuildModifyRecord(entry.first, entry.second, record) != E_OK) {
405 MEDIA_ERR_LOG("OnMdirtyRecords BuildModifyRecord error");
406 continue;
407 }
408 MEDIA_INFO_LOG("enter OnMdirtyRecords Record:%{public}s", record.ToString().c_str());
409 req.AddModifyRecord(record);
410 }
411 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_MDIRTY_RECORDS);
412 FailedSizeResp resp;
413 resp.failedSize = 0;
414 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, req,
415 resp);
416 failSize = resp.failedSize;
417 MEDIA_INFO_LOG("OnMdirtyRecords Resp:%{public}s", resp.ToString().c_str());
418 return ret;
419 }
420
OnFdirtyRecords(const std::map<std::string,MDKRecordOperResult> & map,int32_t & failSize)421 int32_t CloudMediaPhotoHandler::OnFdirtyRecords(
422 const std::map<std::string, MDKRecordOperResult> &map, int32_t &failSize)
423 {
424 MEDIA_INFO_LOG("OnFdirtyRecords, size: %{public}zu", map.size());
425 CHECK_AND_RETURN_RET_LOG(!map.empty(), E_OK, "OnFdirtyRecords records is empty");
426 OnFileDirtyRecordsReqBody req;
427 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_FDIRTY_RECORDS);
428 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
429 for (const auto &entry : map) {
430 OnFileDirtyRecord record;
431 if (dataConvertor.ConvertFdirtyRecord(entry.first, entry.second, record) != E_OK) {
432 MEDIA_ERR_LOG("OnFdirtyRecords ConvertFdirtyRecord Error");
433 continue;
434 }
435 MEDIA_INFO_LOG("OnFdirtyRecords Record: %{public}s", record.ToString().c_str());
436 req.AddRecord(record);
437 DeleteTempLivePhotoFile(record.livePhotoCachePath);
438 }
439 FailedSizeResp resp;
440 resp.failedSize = 0;
441 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, req,
442 resp);
443 failSize = resp.failedSize;
444 MEDIA_INFO_LOG("OnFdirtyRecords Resp:%{public}s", resp.ToString().c_str());
445 return ret;
446 }
447
OnDeleteRecords(const std::map<std::string,MDKRecordOperResult> & map,int32_t & failSize)448 int32_t CloudMediaPhotoHandler::OnDeleteRecords(
449 const std::map<std::string, MDKRecordOperResult> &map, int32_t &failSize)
450 {
451 MEDIA_INFO_LOG("OnDeleteRecords, size: %{public}zu", map.size());
452 CHECK_AND_RETURN_RET_LOG(!map.empty(), E_OK, "OnDeleteRecords records is empty");
453 OnDeleteRecordsPhotosReqBody reqBody;
454 OnDeleteRecordsPhotosRespBody resp;
455 resp.failSize = 0;
456 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_DATA_MODIFY, userId_};
457 for (auto &entry : map) {
458 const MDKRecordOperResult &result = entry.second;
459 OnDeleteRecordsPhoto deleteRecord;
460 deleteRecord.dkRecordId = entry.first;
461 deleteRecord.cloudId = entry.first;
462 deleteRecord.isSuccess = result.IsSuccess();
463 reqBody.AddDeleteRecord(deleteRecord);
464 MEDIA_INFO_LOG("CloudMediaPhotoHandler::OnDeleteRecords ID: %{public}s", deleteRecord.cloudId.c_str());
465 }
466 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_DELETE_RECORDS);
467 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody,
468 resp);
469 failSize = resp.failSize;
470 return ret;
471 }
472
OnCopyRecords(const std::map<std::string,MDKRecordOperResult> & map,int32_t & failSize)473 int32_t CloudMediaPhotoHandler::OnCopyRecords(const std::map<std::string, MDKRecordOperResult> &map, int32_t &failSize)
474 {
475 MEDIA_INFO_LOG("OnCopyRecords, size: %{public}zu", map.size());
476 CHECK_AND_RETURN_RET_LOG(!map.empty(), E_OK, "OnCopyRecords records is empty");
477 OnCopyRecordsPhotosReqBody req;
478 CloudFileDataConvert dataConvertor{CloudOperationType::FILE_COPY, userId_};
479 for (auto &entry : map) {
480 OnCopyRecord copyRecord;
481 if (dataConvertor.BuildCopyRecord(entry.first, entry.second, copyRecord) != E_OK) {
482 MEDIA_ERR_LOG("OnCopyRecords BuildCopyRecord error");
483 continue;
484 }
485 MEDIA_INFO_LOG("OnCopyRecords Record JSON:%{public}s", copyRecord.ToString().c_str());
486 req.AddCopyRecord(copyRecord);
487 }
488 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_COPY_RECORDS);
489 FailedSizeResp resp;
490 resp.failedSize = 0;
491 int32_t ret = IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, req,
492 resp);
493 failSize = resp.failedSize;
494 MEDIA_INFO_LOG("OnCopyRecords Resp:%{public}s", resp.ToString().c_str());
495 return ret;
496 }
497
OnStartSync()498 int32_t CloudMediaPhotoHandler::OnStartSync()
499 {
500 MEDIA_INFO_LOG("OnStartSync enter");
501 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_START_SYNC);
502 return IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode);
503 }
504
OnCompleteSync()505 int32_t CloudMediaPhotoHandler::OnCompleteSync()
506 {
507 MEDIA_INFO_LOG("OnCompleteSync enter");
508 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_COMPLETE_SYNC);
509 return IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode);
510 }
511
OnCompletePull()512 int32_t CloudMediaPhotoHandler::OnCompletePull()
513 {
514 MEDIA_INFO_LOG("OnCompletePull enter");
515 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_COMPLETE_PULL);
516 return IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode);
517 }
518
OnCompletePush()519 int32_t CloudMediaPhotoHandler::OnCompletePush()
520 {
521 MEDIA_INFO_LOG("OnCompletePush enter");
522 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_COMPLETE_PUSH);
523 return IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode);
524 }
525
OnCompleteCheck()526 int32_t CloudMediaPhotoHandler::OnCompleteCheck()
527 {
528 MEDIA_INFO_LOG("OnCompleteCheck begin");
529 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_ON_COMPLETE_CHECK);
530 return IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode);
531 }
532
ReportFailure(const ReportFailureReqBody & reqBody)533 int32_t CloudMediaPhotoHandler::ReportFailure(const ReportFailureReqBody &reqBody)
534 {
535 uint32_t operationCode = static_cast<uint32_t>(CloudMediaPhotoOperationCode::CMD_REPORT_FAILURE);
536 MEDIA_INFO_LOG("ReportFailure begin, reqBody: %{public}s", reqBody.ToString().c_str());
537 return IPC::UserDefineIPCClient().SetUserId(userId_).SetTraceId(this->traceId_).Post(operationCode, reqBody);
538 }
539 } // namespace OHOS::Media::CloudSync