1 /*
2  * Copyright (c) 2023 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 #include "ipc/cloud_sync_service_stub.h"
16 #include "cloud_file_sync_service_interface_code.h"
17 #include "dfs_error.h"
18 #include "dfsu_access_token_helper.h"
19 #include "dfsu_memory_guard.h"
20 #include "task_state_manager.h"
21 #include "utils_log.h"
22 
23 namespace OHOS::FileManagement::CloudSync {
24 using namespace std;
25 
26 static const int READ_SIZE = 100;
27 
CloudSyncServiceStub()28 CloudSyncServiceStub::CloudSyncServiceStub()
29 {
30     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_CALLBACK)] =
31         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleUnRegisterCallbackInner(data, reply); };
32     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_CALLBACK)] =
33         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleRegisterCallbackInner(data, reply); };
34     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_SYNC)] =
35         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStartSyncInner(data, reply); };
36     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_TRIGGER_SYNC)] =
37         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleTriggerSyncInner(data, reply); };
38     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_SYNC)] =
39         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStopSyncInner(data, reply); };
40     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CHANGE_APP_SWITCH)] =
41         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleChangeAppSwitch(data, reply); };
42     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN)] =
43         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleClean(data, reply); };
44     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_DATA_CHANGE)] =
45         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleNotifyDataChange(data, reply); };
46     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_NOTIFY_EVENT_CHANGE)] =
47         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleNotifyEventChange(data, reply); };
48     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_ENABLE_CLOUD)] =
49         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleEnableCloud(data, reply); };
50     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DISABLE_CLOUD)] =
51         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDisableCloud(data, reply); };
52     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_DOWNLOAD_FILE)] =
53         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStartDownloadFile(data, reply); };
54     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_DOWNLOAD_FILE)] =
55         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStopDownloadFile(data, reply); };
56     opToInterfaceMap_[static_cast<uint32_t>(
57         CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_FILE_CALLBACK)] =
58         [this](MessageParcel &data, MessageParcel &reply) {
59             return this->HandleRegisterDownloadFileCallback(data, reply);
60         };
61     opToInterfaceMap_[static_cast<uint32_t>(
62         CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UNREGISTER_DOWNLOAD_FILE_CALLBACK)] =
63         [this](MessageParcel &data, MessageParcel &reply) {
64             return this->HandleUnregisterDownloadFileCallback(data, reply);
65         };
66     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_UPLOAD_ASSET)] =
67         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleUploadAsset(data, reply); };
68     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILE)] =
69         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDownloadFile(data, reply); };
70     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_FILES)] =
71         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDownloadFiles(data, reply); };
72     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DOWNLOAD_ASSET)] =
73         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDownloadAsset(data, reply); };
74     opToInterfaceMap_[static_cast<uint32_t>(
75         CloudFileSyncServiceInterfaceCode::SERVICE_CMD_REGISTER_DOWNLOAD_ASSET_CALLBACK)] =
76         [this](MessageParcel &data, MessageParcel &reply) {
77             return this->HandleRegisterDownloadAssetCallback(data, reply);
78         };
79     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_DELETE_ASSET)] =
80         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleDeleteAsset(data, reply); };
81     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_GET_SYNC_TIME)] =
82         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleGetSyncTime(data, reply); };
83     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_CLEAN_CACHE)] =
84         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleCleanCache(data, reply); };
85     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_START_FILE_CACHE)] =
86         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStartFileCache(data, reply); };
87     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_RESET_CURSOR)] =
88         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleResetCursor(data, reply); };
89     opToInterfaceMap_[static_cast<uint32_t>(CloudFileSyncServiceInterfaceCode::SERVICE_CMD_STOP_FILE_CACHE)] =
90         [this](MessageParcel &data, MessageParcel &reply) { return this->HandleStopFileCache(data, reply); };
91 }
92 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)93 int32_t CloudSyncServiceStub::OnRemoteRequest(uint32_t code,
94                                               MessageParcel &data,
95                                               MessageParcel &reply,
96                                               MessageOption &option)
97 {
98     DfsuMemoryGuard cacheGuard;
99     TaskStateManager::GetInstance().StartTask();
100     if (data.ReadInterfaceToken() != GetDescriptor()) {
101         return E_SERVICE_DESCRIPTOR_IS_EMPTY;
102     }
103     auto interfaceIndex = opToInterfaceMap_.find(code);
104     if (interfaceIndex == opToInterfaceMap_.end() || !interfaceIndex->second) {
105         LOGE("Cannot response request %d: unknown tranction", code);
106         return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
107     }
108     auto memberFunc = interfaceIndex->second;
109     return memberFunc(data, reply);
110 }
111 
HandleUnRegisterCallbackInner(MessageParcel & data,MessageParcel & reply)112 int32_t CloudSyncServiceStub::HandleUnRegisterCallbackInner(MessageParcel &data, MessageParcel &reply)
113 {
114     LOGI("Begin UnRegisterCallbackInner");
115     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
116         LOGE("permission denied");
117         return E_PERMISSION_DENIED;
118     }
119     if (!DfsuAccessTokenHelper::IsSystemApp()) {
120         LOGE("caller hap is not system hap");
121         return E_PERMISSION_SYSTEM;
122     }
123 
124     string bundleName = data.ReadString();
125     int32_t res = UnRegisterCallbackInner(bundleName);
126     reply.WriteInt32(res);
127     LOGI("End UnRegisterCallbackInner");
128     return E_OK;
129 }
130 
HandleRegisterCallbackInner(MessageParcel & data,MessageParcel & reply)131 int32_t CloudSyncServiceStub::HandleRegisterCallbackInner(MessageParcel &data, MessageParcel &reply)
132 {
133     LOGI("Begin RegisterCallbackInner");
134     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
135         LOGE("permission denied");
136         return E_PERMISSION_DENIED;
137     }
138     if (!DfsuAccessTokenHelper::IsSystemApp()) {
139         LOGE("caller hap is not system hap");
140         return E_PERMISSION_SYSTEM;
141     }
142     auto remoteObj = data.ReadRemoteObject();
143     string bundleName = data.ReadString();
144     int32_t res = RegisterCallbackInner(remoteObj, bundleName);
145     reply.WriteInt32(res);
146     LOGI("End RegisterCallbackInner");
147     return E_OK;
148 }
149 
HandleStartSyncInner(MessageParcel & data,MessageParcel & reply)150 int32_t CloudSyncServiceStub::HandleStartSyncInner(MessageParcel &data, MessageParcel &reply)
151 {
152     LOGI("Begin StartSyncInner");
153     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
154         LOGE("permission denied");
155         return E_PERMISSION_DENIED;
156     }
157     if (!DfsuAccessTokenHelper::IsSystemApp()) {
158         LOGE("caller hap is not system hap");
159         return E_PERMISSION_SYSTEM;
160     }
161     auto forceFlag = data.ReadBool();
162     string bundleName = data.ReadString();
163     int32_t res = StartSyncInner(forceFlag, bundleName);
164     reply.WriteInt32(res);
165     LOGI("End StartSyncInner");
166     return E_OK;
167 }
168 
HandleTriggerSyncInner(MessageParcel & data,MessageParcel & reply)169 int32_t CloudSyncServiceStub::HandleTriggerSyncInner(MessageParcel &data, MessageParcel &reply)
170 {
171     LOGI("Begin TriggerSyncInner");
172     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
173         LOGE("permission denied");
174         return E_PERMISSION_DENIED;
175     }
176     if (!DfsuAccessTokenHelper::IsSystemApp()) {
177         LOGE("caller hap is not system hap");
178         return E_PERMISSION_SYSTEM;
179     }
180     string bundleName = data.ReadString();
181     int32_t userId = data.ReadInt32();
182     int32_t res = TriggerSyncInner(bundleName, userId);
183     reply.WriteInt32(res);
184     LOGI("End TriggerSyncInner");
185     return E_OK;
186 }
187 
HandleStopSyncInner(MessageParcel & data,MessageParcel & reply)188 int32_t CloudSyncServiceStub::HandleStopSyncInner(MessageParcel &data, MessageParcel &reply)
189 {
190     LOGI("Begin StopSyncInner");
191     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
192         LOGE("permission denied");
193         return E_PERMISSION_DENIED;
194     }
195     if (!DfsuAccessTokenHelper::IsSystemApp()) {
196         LOGE("caller hap is not system hap");
197         return E_PERMISSION_SYSTEM;
198     }
199 
200     string bundleName = data.ReadString();
201     bool forceFlag = data.ReadBool();
202     int32_t res = StopSyncInner(bundleName, forceFlag);
203     reply.WriteInt32(res);
204     LOGI("End StopSyncInner");
205     return E_OK;
206 }
207 
HandleResetCursor(MessageParcel & data,MessageParcel & reply)208 int32_t CloudSyncServiceStub::HandleResetCursor(MessageParcel &data, MessageParcel &reply)
209 {
210     LOGI("Begin ResetCursor");
211     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
212         LOGE("permission denied");
213         return E_PERMISSION_DENIED;
214     }
215     if (!DfsuAccessTokenHelper::IsSystemApp()) {
216         LOGE("caller hap is not system hap");
217         return E_PERMISSION_SYSTEM;
218     }
219 
220     string bundleName = data.ReadString();
221     int32_t res = ResetCursor(bundleName);
222     reply.WriteInt32(res);
223     LOGI("End ResetCursor");
224     return E_OK;
225 }
226 
HandleChangeAppSwitch(MessageParcel & data,MessageParcel & reply)227 int32_t CloudSyncServiceStub::HandleChangeAppSwitch(MessageParcel &data, MessageParcel &reply)
228 {
229     LOGI("Begin ChangeAppSwitch");
230     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
231         LOGE("permission denied");
232         return E_PERMISSION_DENIED;
233     }
234     if (!DfsuAccessTokenHelper::IsSystemApp()) {
235         LOGE("caller hap is not system hap");
236         return E_PERMISSION_SYSTEM;
237     }
238     string accountId = data.ReadString();
239     string bundleName = data.ReadString();
240     bool status = data.ReadBool();
241     int32_t res = ChangeAppSwitch(accountId, bundleName, status);
242     reply.WriteInt32(res);
243     LOGI("End ChangeAppSwitch");
244     return E_OK;
245 }
246 
HandleClean(MessageParcel & data,MessageParcel & reply)247 int32_t CloudSyncServiceStub::HandleClean(MessageParcel &data, MessageParcel &reply)
248 {
249     LOGI("Begin Clean");
250     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
251         LOGE("permission denied");
252         return E_PERMISSION_DENIED;
253     }
254     if (!DfsuAccessTokenHelper::IsSystemApp()) {
255         LOGE("caller hap is not system hap");
256         return E_PERMISSION_SYSTEM;
257     }
258     string accountId = data.ReadString();
259     sptr<CleanOptions> options = data.ReadParcelable<CleanOptions>();
260     if (!options) {
261         LOGE("object of CleanOptions is nullptr");
262         return E_INVAL_ARG;
263     }
264     int32_t res = Clean(accountId, *options);
265     reply.WriteInt32(res);
266     LOGI("End Clean");
267     return E_OK;
268 }
269 
HandleNotifyDataChange(MessageParcel & data,MessageParcel & reply)270 int32_t CloudSyncServiceStub::HandleNotifyDataChange(MessageParcel &data, MessageParcel &reply)
271 {
272     LOGI("Begin NotifyDataChange");
273     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
274         LOGE("permission denied");
275         return E_PERMISSION_DENIED;
276     }
277     if (!DfsuAccessTokenHelper::IsSystemApp()) {
278         LOGE("caller hap is not system hap");
279         return E_PERMISSION_SYSTEM;
280     }
281     string accountId = data.ReadString();
282     string bundleName = data.ReadString();
283     int32_t res = NotifyDataChange(accountId, bundleName);
284     reply.WriteInt32(res);
285     LOGI("End NotifyDataChange");
286     return E_OK;
287 }
288 
HandleNotifyEventChange(MessageParcel & data,MessageParcel & reply)289 int32_t CloudSyncServiceStub::HandleNotifyEventChange(MessageParcel &data, MessageParcel &reply)
290 {
291     LOGI("Begin NotifyEventChange");
292     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
293         LOGE("permission denied");
294         return E_PERMISSION_DENIED;
295     }
296     if (!DfsuAccessTokenHelper::IsSystemApp()) {
297         LOGE("caller hap is not system hap");
298         return E_PERMISSION_SYSTEM;
299     }
300     int32_t userId = data.ReadInt32();
301     string eventIdStr = data.ReadString();
302     string extraDataStr = data.ReadString();
303 
304     int32_t res = NotifyEventChange(userId, eventIdStr, extraDataStr);
305     reply.WriteInt32(res);
306     LOGI("End NotifyEventChange");
307     return E_OK;
308 }
309 
HandleDisableCloud(MessageParcel & data,MessageParcel & reply)310 int32_t CloudSyncServiceStub::HandleDisableCloud(MessageParcel &data, MessageParcel &reply)
311 {
312     LOGI("Begin DisableCloud");
313     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
314         LOGE("permission denied");
315         return E_PERMISSION_DENIED;
316     }
317     if (!DfsuAccessTokenHelper::IsSystemApp()) {
318         LOGE("caller hap is not system hap");
319         return E_PERMISSION_SYSTEM;
320     }
321     string accountId = data.ReadString();
322     int32_t res = DisableCloud(accountId);
323     reply.WriteInt32(res);
324     LOGI("End DisableCloud");
325     return E_OK;
326 }
HandleEnableCloud(MessageParcel & data,MessageParcel & reply)327 int32_t CloudSyncServiceStub::HandleEnableCloud(MessageParcel &data, MessageParcel &reply)
328 {
329     LOGI("Begin EnableCloud");
330     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC_MANAGER)) {
331         LOGE("permission denied");
332         return E_PERMISSION_DENIED;
333     }
334     if (!DfsuAccessTokenHelper::IsSystemApp()) {
335         LOGE("caller hap is not system hap");
336         return E_PERMISSION_SYSTEM;
337     }
338     string accountId = data.ReadString();
339     sptr<SwitchDataObj> switchObj = data.ReadParcelable<SwitchDataObj>();
340     if (!switchObj) {
341         LOGE("object of SwitchDataObj is nullptr");
342         return E_INVAL_ARG;
343     }
344     int32_t res = EnableCloud(accountId, *switchObj);
345     reply.WriteInt32(res);
346     LOGI("End EnableCloud");
347     return E_OK;
348 }
349 
HandleStartDownloadFile(MessageParcel & data,MessageParcel & reply)350 int32_t CloudSyncServiceStub::HandleStartDownloadFile(MessageParcel &data, MessageParcel &reply)
351 {
352     LOGI("Begin HandleStartDownloadFile");
353     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
354         LOGE("permission denied");
355         return E_PERMISSION_DENIED;
356     }
357     if (!DfsuAccessTokenHelper::IsSystemApp()) {
358         LOGE("caller hap is not system hap");
359         return E_PERMISSION_SYSTEM;
360     }
361     string path = data.ReadString();
362 
363     int32_t res = StartDownloadFile(path);
364     reply.WriteInt32(res);
365     LOGI("End HandleStartDownloadFile");
366     return E_OK;
367 }
368 
HandleStartFileCache(MessageParcel & data,MessageParcel & reply)369 int32_t CloudSyncServiceStub::HandleStartFileCache(MessageParcel &data, MessageParcel &reply)
370 {
371     LOGI("Begin HandleStartFileCache");
372     if (!DfsuAccessTokenHelper::IsSystemApp()) {
373         LOGE("caller hap is not system hap");
374         return E_PERMISSION_SYSTEM;
375     }
376     std::vector<std::string> pathVec;
377     if (!data.ReadStringVector(&pathVec)) {
378         LOGE("Failed to get the cloud id.");
379         return E_INVAL_ARG;
380     }
381     int32_t fieldkey = data.ReadInt32();
382 
383     bool isCallbackValid = data.ReadBool();
384 
385     sptr<IRemoteObject> downloadCallback = nullptr;
386     if (isCallbackValid) {
387         downloadCallback = data.ReadRemoteObject();
388     }
389 
390     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_AUTH_URI)) {
391         for (auto &uri : pathVec) {
392             if (!DfsuAccessTokenHelper::CheckUriPermission(uri)) {
393                 LOGE("permission denied");
394                 return E_PERMISSION_DENIED;
395             }
396         }
397     }
398     int64_t downloadId = 0;
399     int32_t res = StartFileCache(pathVec, downloadId, fieldkey, isCallbackValid, downloadCallback);
400     reply.WriteInt64(downloadId);
401     reply.WriteInt32(res);
402     LOGI("End HandleStartFileCache");
403     return E_OK;
404 }
405 
HandleStopDownloadFile(MessageParcel & data,MessageParcel & reply)406 int32_t CloudSyncServiceStub::HandleStopDownloadFile(MessageParcel &data, MessageParcel &reply)
407 {
408     LOGI("Begin HandleStopDownloadFile");
409     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
410         LOGE("permission denied");
411         return E_PERMISSION_DENIED;
412     }
413     if (!DfsuAccessTokenHelper::IsSystemApp()) {
414         LOGE("caller hap is not system hap");
415         return E_PERMISSION_SYSTEM;
416     }
417     string path = data.ReadString();
418     bool needClean = data.ReadBool();
419 
420     int32_t res = StopDownloadFile(path, needClean);
421     reply.WriteInt32(res);
422     LOGI("End HandleStopDownloadFile");
423     return E_OK;
424 }
425 
HandleStopFileCache(MessageParcel & data,MessageParcel & reply)426 int32_t CloudSyncServiceStub::HandleStopFileCache(MessageParcel &data, MessageParcel &reply)
427 {
428     LOGI("Begin HandleStopFileCache");
429     if (!DfsuAccessTokenHelper::IsSystemApp()) {
430         LOGE("caller hap is not system hap");
431         return E_PERMISSION_SYSTEM;
432     }
433     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_AUTH_URI)) {
434         LOGE("permission denied");
435         return E_PERMISSION_DENIED;
436     }
437     int64_t downloadId = data.ReadInt64();
438     bool needClean = data.ReadBool();
439 
440     int32_t res = StopFileCache(downloadId, needClean);
441     reply.WriteInt32(res);
442     LOGI("End HandleStopFileCache");
443     return E_OK;
444 }
445 
HandleRegisterDownloadFileCallback(MessageParcel & data,MessageParcel & reply)446 int32_t CloudSyncServiceStub::HandleRegisterDownloadFileCallback(MessageParcel &data, MessageParcel &reply)
447 {
448     LOGI("Begin HandleRegisterDownloadFileCallback");
449     if (!DfsuAccessTokenHelper::IsSystemApp()) {
450         LOGE("caller hap is not system hap");
451         return E_PERMISSION_SYSTEM;
452     }
453 
454     auto downloadCallback = data.ReadRemoteObject();
455 
456     int32_t res = RegisterDownloadFileCallback(downloadCallback);
457     reply.WriteInt32(res);
458     LOGI("End HandleRegisterDownloadFileCallback");
459     return E_OK;
460 }
461 
HandleUnregisterDownloadFileCallback(MessageParcel & data,MessageParcel & reply)462 int32_t CloudSyncServiceStub::HandleUnregisterDownloadFileCallback(MessageParcel &data, MessageParcel &reply)
463 {
464     LOGI("Begin HandleUnregisterDownloadFileCallback");
465     if (!DfsuAccessTokenHelper::IsSystemApp()) {
466         LOGE("caller hap is not system hap");
467         return E_PERMISSION_SYSTEM;
468     }
469 
470     int32_t res = UnregisterDownloadFileCallback();
471     reply.WriteInt32(res);
472     LOGI("End HandleUnregisterDownloadFileCallback");
473     return E_OK;
474 }
475 
HandleUploadAsset(MessageParcel & data,MessageParcel & reply)476 int32_t CloudSyncServiceStub::HandleUploadAsset(MessageParcel &data, MessageParcel &reply)
477 {
478     LOGI("Begin UploadAsset");
479     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
480         LOGE("permission denied");
481         return E_PERMISSION_DENIED;
482     }
483     if (!DfsuAccessTokenHelper::IsSystemApp()) {
484         LOGE("caller hap is not system hap");
485         return E_PERMISSION_SYSTEM;
486     }
487     int32_t userId = data.ReadInt32();
488     string request = data.ReadString();
489     string result;
490     int32_t res = UploadAsset(userId, request, result);
491     reply.WriteInt32(res);
492     reply.WriteString(result);
493     LOGI("End UploadAsset");
494     return E_OK;
495 }
496 
HandleDownloadFile(MessageParcel & data,MessageParcel & reply)497 int32_t CloudSyncServiceStub::HandleDownloadFile(MessageParcel &data, MessageParcel &reply)
498 {
499     LOGI("Begin DownloadFile");
500     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
501         LOGE("permission denied");
502         return E_PERMISSION_DENIED;
503     }
504     if (!DfsuAccessTokenHelper::IsSystemApp()) {
505         LOGE("caller hap is not system hap");
506         return E_PERMISSION_SYSTEM;
507     }
508     int32_t userId = data.ReadInt32();
509     string bundleName = data.ReadString();
510     sptr<AssetInfoObj> assetInfoObj = data.ReadParcelable<AssetInfoObj>();
511     if (!assetInfoObj) {
512         LOGE("object of AssetInfoObj is nullptr");
513         return E_INVAL_ARG;
514     }
515     int32_t res = DownloadFile(userId, bundleName, *assetInfoObj);
516     reply.WriteInt32(res);
517     LOGI("End DownloadFile");
518     return E_OK;
519 }
520 
HandleDownloadFiles(MessageParcel & data,MessageParcel & reply)521 int32_t CloudSyncServiceStub::HandleDownloadFiles(MessageParcel &data, MessageParcel &reply)
522 {
523     LOGI("Begin DownloadFile");
524     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
525         LOGE("permission denied");
526         return E_PERMISSION_DENIED;
527     }
528     if (!DfsuAccessTokenHelper::IsSystemApp()) {
529         LOGE("caller hap is not system hap");
530         return E_PERMISSION_SYSTEM;
531     }
532     int32_t userId = data.ReadInt32();
533     string bundleName = data.ReadString();
534     int32_t size = data.ReadInt32();
535     std::vector<AssetInfoObj> assetInfoObj;
536     if (size > READ_SIZE) {
537         return E_INVAL_ARG;
538     }
539     for (int i = 0; i < size; i++) {
540         sptr<AssetInfoObj> obj = data.ReadParcelable<AssetInfoObj>();
541         if (!obj) {
542             LOGE("object of obj is nullptr");
543             return E_INVAL_ARG;
544         }
545         assetInfoObj.emplace_back(*obj);
546     }
547 
548     std::vector<bool> assetResultMap;
549     int32_t res = DownloadFiles(userId, bundleName, assetInfoObj, assetResultMap);
550     reply.WriteBoolVector(assetResultMap);
551     reply.WriteInt32(res);
552     LOGI("End DownloadFiles");
553     return E_OK;
554 }
555 
HandleDownloadAsset(MessageParcel & data,MessageParcel & reply)556 int32_t CloudSyncServiceStub::HandleDownloadAsset(MessageParcel &data, MessageParcel &reply)
557 {
558     LOGI("Begin DownloadAsset");
559     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
560         LOGE("permission denied");
561         return E_PERMISSION_DENIED;
562     }
563     if (!DfsuAccessTokenHelper::IsSystemApp()) {
564         LOGE("caller hap is not system hap");
565         return E_PERMISSION_SYSTEM;
566     }
567     uint64_t taskId = data.ReadUint64();
568     int32_t userId = data.ReadInt32();
569     string bundleName = data.ReadString();
570     string networkId = data.ReadString();
571     sptr<AssetInfoObj> assetInfoObj = data.ReadParcelable<AssetInfoObj>();
572     if (!assetInfoObj) {
573         LOGE("object of AssetInfoObj is nullptr");
574         return E_INVAL_ARG;
575     }
576     int32_t res = DownloadAsset(taskId, userId, bundleName, networkId, *assetInfoObj);
577     reply.WriteInt32(res);
578     LOGI("End DownloadAsset");
579     return E_OK;
580 }
581 
HandleRegisterDownloadAssetCallback(MessageParcel & data,MessageParcel & reply)582 int32_t CloudSyncServiceStub::HandleRegisterDownloadAssetCallback(MessageParcel &data, MessageParcel &reply)
583 {
584     LOGI("Begin RegisterDownloadAssetCallback");
585     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
586         LOGE("permission denied");
587         return E_PERMISSION_DENIED;
588     }
589     if (!DfsuAccessTokenHelper::IsSystemApp()) {
590         LOGE("caller hap is not system hap");
591         return E_PERMISSION_SYSTEM;
592     }
593     auto remoteObj = data.ReadRemoteObject();
594     int32_t res = RegisterDownloadAssetCallback(remoteObj);
595     reply.WriteInt32(res);
596     LOGI("End RegisterDownloadAssetCallback");
597     return E_OK;
598 }
599 
HandleDeleteAsset(MessageParcel & data,MessageParcel & reply)600 int32_t CloudSyncServiceStub::HandleDeleteAsset(MessageParcel &data, MessageParcel &reply)
601 {
602     LOGI("Begin DeleteAsset");
603     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
604         LOGE("permission denied");
605         return E_PERMISSION_DENIED;
606     }
607     if (!DfsuAccessTokenHelper::IsSystemApp()) {
608         LOGE("caller hap is not system hap");
609         return E_PERMISSION_SYSTEM;
610     }
611     int32_t userId = data.ReadInt32();
612     string uri = data.ReadString();
613     int32_t res = DeleteAsset(userId, uri);
614     reply.WriteInt32(res);
615     reply.WriteString(uri);
616     LOGI("End DeleteAsset");
617     return E_OK;
618 }
619 
HandleGetSyncTime(MessageParcel & data,MessageParcel & reply)620 int32_t CloudSyncServiceStub::HandleGetSyncTime(MessageParcel &data, MessageParcel &reply)
621 {
622     LOGI("Begin GetSyncTime");
623     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
624         LOGE("permission denied");
625         return E_PERMISSION_DENIED;
626     }
627     if (!DfsuAccessTokenHelper::IsSystemApp()) {
628         LOGE("caller hap is not system hap");
629         return E_PERMISSION_SYSTEM;
630     }
631 
632     int64_t syncTime = 0;
633     string bundleName = data.ReadString();
634     int32_t res = GetSyncTimeInner(syncTime, bundleName);
635     reply.WriteInt64(syncTime);
636     reply.WriteInt32(res);
637     return E_OK;
638 }
639 
HandleCleanCache(MessageParcel & data,MessageParcel & reply)640 int32_t CloudSyncServiceStub::HandleCleanCache(MessageParcel &data, MessageParcel &reply)
641 {
642     LOGI("Begin HandleCleanCache");
643     if (!DfsuAccessTokenHelper::CheckCallerPermission(PERM_CLOUD_SYNC)) {
644         LOGE("permission denied");
645         return E_PERMISSION_DENIED;
646     }
647     if (!DfsuAccessTokenHelper::IsSystemApp()) {
648         LOGE("caller hap is not system hap");
649         return E_PERMISSION_SYSTEM;
650     }
651 
652     string uri = data.ReadString();
653     int32_t res = CleanCacheInner(uri);
654 
655     reply.WriteInt32(res);
656     return E_OK;
657 }
658 } // namespace OHOS::FileManagement::CloudSync
659