1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "service_reverse.h"
17
18 #include "b_error/b_error.h"
19 #include "b_radar/b_radar.h"
20 #include "filemgmt_libhilog.h"
21
22 namespace OHOS::FileManagement::Backup {
23 using namespace std;
24
IncrementalBackupOnFileReady(string bundleName,string fileName,int fd,int manifestFd,int32_t errCode)25 void ServiceReverse::IncrementalBackupOnFileReady(string bundleName, string fileName, int fd, int manifestFd,
26 int32_t errCode)
27 {
28 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) {
29 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
30 return;
31 }
32 BFileInfo bFileInfo(bundleName, fileName, 0);
33 callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode);
34 }
35
IncrementalBackupOnBundleStarted(int32_t errCode,string bundleName)36 void ServiceReverse::IncrementalBackupOnBundleStarted(int32_t errCode, string bundleName)
37 {
38 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleStarted) {
39 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
40 return;
41 }
42 callbacksIncrementalBackup_.onBundleStarted(errCode, bundleName);
43 }
44
IncrementalBackupOnResultReport(std::string result,std::string bundleName)45 void ServiceReverse::IncrementalBackupOnResultReport(std::string result, std::string bundleName)
46 {
47 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onResultReport) {
48 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
49 return;
50 }
51 callbacksIncrementalBackup_.onResultReport(bundleName, result);
52 }
53
IncrementalBackupOnBundleFinished(int32_t errCode,string bundleName)54 void ServiceReverse::IncrementalBackupOnBundleFinished(int32_t errCode, string bundleName)
55 {
56 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleFinished) {
57 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
58 return;
59 }
60 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
61 callbacksIncrementalBackup_.onBundleFinished(errCode, bundleName);
62 }
63
IncrementalBackupOnAllBundlesFinished(int32_t errCode)64 void ServiceReverse::IncrementalBackupOnAllBundlesFinished(int32_t errCode)
65 {
66 HILOGI("errCode = %{public}d", errCode);
67 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onAllBundlesFinished) {
68 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
69 return;
70 }
71 callbacksIncrementalBackup_.onAllBundlesFinished(errCode);
72 }
73
IncrementalBackupOnProcessInfo(std::string bundleName,std::string processInfo)74 void ServiceReverse::IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo)
75 {
76 HILOGI("bundleName = %{public}s", bundleName.c_str());
77 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onProcess) {
78 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
79 return;
80 }
81 callbacksIncrementalBackup_.onProcess(bundleName, processInfo);
82 }
83
IncrementalBackupOnScanningInfo(std::string scannedInfo)84 void ServiceReverse::IncrementalBackupOnScanningInfo(std::string scannedInfo)
85 {
86 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBackupSizeReport) {
87 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
88 return;
89 }
90 callbacksIncrementalBackup_.onBackupSizeReport(scannedInfo);
91 }
92
IncrementalRestoreOnBundleStarted(int32_t errCode,string bundleName)93 void ServiceReverse::IncrementalRestoreOnBundleStarted(int32_t errCode, string bundleName)
94 {
95 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleStarted) {
96 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
97 return;
98 }
99 callbacksIncrementalRestore_.onBundleStarted(errCode, bundleName);
100 }
101
IncrementalRestoreOnBundleFinished(int32_t errCode,string bundleName)102 void ServiceReverse::IncrementalRestoreOnBundleFinished(int32_t errCode, string bundleName)
103 {
104 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) {
105 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
106 return;
107 }
108 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
109 callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName);
110 }
111
IncrementalRestoreOnAllBundlesFinished(int32_t errCode)112 void ServiceReverse::IncrementalRestoreOnAllBundlesFinished(int32_t errCode)
113 {
114 HILOGI("errCode = %{public}d", errCode);
115 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onAllBundlesFinished) {
116 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
117 return;
118 }
119 callbacksIncrementalRestore_.onAllBundlesFinished(errCode);
120 }
121
IncrementalRestoreOnFileReady(string bundleName,string fileName,int fd,int manifestFd,int32_t errCode)122 void ServiceReverse::IncrementalRestoreOnFileReady(string bundleName, string fileName, int fd, int manifestFd,
123 int32_t errCode)
124 {
125 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onFileReady) {
126 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
127 return;
128 }
129 BFileInfo bFileInfo(bundleName, fileName, 0);
130 callbacksIncrementalRestore_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode);
131 }
132
IncrementalRestoreOnResultReport(std::string result,std::string bundleName,ErrCode errCode)133 void ServiceReverse::IncrementalRestoreOnResultReport(std::string result, std::string bundleName, ErrCode errCode)
134 {
135 HILOGI("begin incremental restore on result report, bundleName:%{public}s", bundleName.c_str());
136 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onResultReport) {
137 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
138 return;
139 }
140 callbacksIncrementalRestore_.onResultReport(bundleName, result);
141 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) {
142 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
143 return;
144 }
145 callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName);
146 }
147
IncrementalRestoreOnProcessInfo(std::string bundleName,std::string processInfo)148 void ServiceReverse::IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo)
149 {
150 HILOGI("begin incremental report processInfo, bundleName:%{public}s", bundleName.c_str());
151 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onProcess) {
152 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
153 return;
154 }
155 callbacksIncrementalRestore_.onProcess(bundleName, processInfo);
156 }
157
ServiceReverse(BIncrementalBackupSession::Callbacks callbacks)158 ServiceReverse::ServiceReverse(BIncrementalBackupSession::Callbacks callbacks)
159 : scenario_(Scenario::BACKUP), callbacksIncrementalBackup_(callbacks)
160 {
161 }
162
ServiceReverse(BIncrementalRestoreSession::Callbacks callbacks)163 ServiceReverse::ServiceReverse(BIncrementalRestoreSession::Callbacks callbacks)
164 : scenario_(Scenario::RESTORE), callbacksIncrementalRestore_(callbacks)
165 {
166 }
167 } // namespace OHOS::FileManagement::Backup