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(const std::string & bundleName,const std::string & fileName,int fd,int manifestFd,int32_t errCode)25 ErrCode ServiceReverse::IncrementalBackupOnFileReady(const std::string &bundleName,
26 const std::string &fileName,
27 int fd,
28 int manifestFd,
29 int32_t errCode)
30 {
31 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) {
32 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
33 return BError(BError::Codes::OK);
34 }
35 BFileInfo bFileInfo(bundleName, fileName, 0);
36 callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode);
37 return BError(BError::Codes::OK);
38 }
39
IncrementalSaBackupOnFileReady(const std::string & bundleName,const std::string & fileName,int fd,int32_t errCode)40 ErrCode ServiceReverse::IncrementalSaBackupOnFileReady(const std::string &bundleName, const std::string &fileName,
41 int fd, int32_t errCode)
42 {
43 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) {
44 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
45 return BError(BError::Codes::OK);
46 }
47 BFileInfo bFileInfo(bundleName, fileName, 0);
48 callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(INVALID_FD), errCode);
49 return BError(BError::Codes::OK);
50 }
51
IncrementalBackupOnFileReadyWithoutFd(const std::string & bundleName,const std::string & fileName,int32_t errCode)52 ErrCode ServiceReverse::IncrementalBackupOnFileReadyWithoutFd(const std::string &bundleName,
53 const std::string &fileName,
54 int32_t errCode)
55 {
56 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) {
57 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
58 return BError(BError::Codes::OK);
59 }
60 BFileInfo bFileInfo(bundleName, fileName, 0);
61 callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(INVALID_FD), UniqueFd(INVALID_FD), errCode);
62 return BError(BError::Codes::OK);
63 }
64
IncrementalBackupOnBundleStarted(int32_t errCode,const std::string & bundleName)65 ErrCode ServiceReverse::IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName)
66 {
67 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleStarted) {
68 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
69 return BError(BError::Codes::OK);
70 }
71 callbacksIncrementalBackup_.onBundleStarted(errCode, bundleName);
72 return BError(BError::Codes::OK);
73 }
74
IncrementalBackupOnResultReport(const std::string & result,const std::string & bundleName)75 ErrCode ServiceReverse::IncrementalBackupOnResultReport(const std::string &result, const std::string &bundleName)
76 {
77 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onResultReport) {
78 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
79 return BError(BError::Codes::OK);
80 }
81 callbacksIncrementalBackup_.onResultReport(bundleName, result);
82 return BError(BError::Codes::OK);
83 }
84
IncrementalBackupOnBundleFinished(int32_t errCode,const std::string & bundleName)85 ErrCode ServiceReverse::IncrementalBackupOnBundleFinished(int32_t errCode, const std::string &bundleName)
86 {
87 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleFinished) {
88 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
89 return BError(BError::Codes::OK);
90 }
91 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
92 callbacksIncrementalBackup_.onBundleFinished(errCode, bundleName);
93 return BError(BError::Codes::OK);
94 }
95
IncrementalBackupOnAllBundlesFinished(int32_t errCode)96 ErrCode ServiceReverse::IncrementalBackupOnAllBundlesFinished(int32_t errCode)
97 {
98 HILOGI("errCode = %{public}d", errCode);
99 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onAllBundlesFinished) {
100 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
101 return BError(BError::Codes::OK);
102 }
103 callbacksIncrementalBackup_.onAllBundlesFinished(errCode);
104 return BError(BError::Codes::OK);
105 }
106
IncrementalBackupOnProcessInfo(const std::string & bundleName,const std::string & processInfo)107 ErrCode ServiceReverse::IncrementalBackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo)
108 {
109 HILOGI("bundleName = %{public}s", bundleName.c_str());
110 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onProcess) {
111 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
112 return BError(BError::Codes::OK);
113 }
114 callbacksIncrementalBackup_.onProcess(bundleName, processInfo);
115 return BError(BError::Codes::OK);
116 }
117
IncrementalBackupOnScanningInfo(const std::string & scannedInfo)118 ErrCode ServiceReverse::IncrementalBackupOnScanningInfo(const std::string &scannedInfo)
119 {
120 if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBackupSizeReport) {
121 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
122 return BError(BError::Codes::OK);
123 }
124 callbacksIncrementalBackup_.onBackupSizeReport(scannedInfo);
125 return BError(BError::Codes::OK);
126 }
127
IncrementalRestoreOnBundleStarted(int32_t errCode,const std::string & bundleName)128 ErrCode ServiceReverse::IncrementalRestoreOnBundleStarted(int32_t errCode, const std::string &bundleName)
129 {
130 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleStarted) {
131 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
132 return BError(BError::Codes::OK);
133 }
134 callbacksIncrementalRestore_.onBundleStarted(errCode, bundleName);
135 return BError(BError::Codes::OK);
136 }
137
IncrementalRestoreOnBundleFinished(int32_t errCode,const std::string & bundleName)138 ErrCode ServiceReverse::IncrementalRestoreOnBundleFinished(int32_t errCode, const std::string &bundleName)
139 {
140 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) {
141 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
142 return BError(BError::Codes::OK);
143 }
144 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
145 callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName);
146 return BError(BError::Codes::OK);
147 }
148
IncrementalRestoreOnAllBundlesFinished(int32_t errCode)149 ErrCode ServiceReverse::IncrementalRestoreOnAllBundlesFinished(int32_t errCode)
150 {
151 HILOGI("errCode = %{public}d", errCode);
152 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onAllBundlesFinished) {
153 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
154 return BError(BError::Codes::OK);
155 }
156 callbacksIncrementalRestore_.onAllBundlesFinished(errCode);
157 return BError(BError::Codes::OK);
158 }
159
IncrementalRestoreOnFileReady(const std::string & bundleName,const std::string & fileName,int fd,int manifestFd,int32_t errCode)160 ErrCode ServiceReverse::IncrementalRestoreOnFileReady(const std::string &bundleName,
161 const std::string &fileName,
162 int fd,
163 int manifestFd,
164 int32_t errCode)
165 {
166 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onFileReady) {
167 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
168 return BError(BError::Codes::OK);
169 }
170 BFileInfo bFileInfo(bundleName, fileName, 0);
171 callbacksIncrementalRestore_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode);
172 return BError(BError::Codes::OK);
173 }
174
IncrementalRestoreOnFileReadyWithoutFd(const std::string & bundleName,const std::string & fileName,int32_t errCode)175 ErrCode ServiceReverse::IncrementalRestoreOnFileReadyWithoutFd(const std::string &bundleName,
176 const std::string &fileName,
177 int32_t errCode)
178 {
179 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onFileReady) {
180 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
181 return BError(BError::Codes::OK);
182 }
183 BFileInfo bFileInfo(bundleName, fileName, 0);
184 callbacksIncrementalRestore_.onFileReady(bFileInfo, UniqueFd(INVALID_FD), UniqueFd(INVALID_FD), errCode);
185 return BError(BError::Codes::OK);
186 }
187
IncrementalRestoreOnResultReport(const std::string & result,const std::string & bundleName,ErrCode errCode)188 ErrCode ServiceReverse::IncrementalRestoreOnResultReport(const std::string &result,
189 const std::string &bundleName,
190 ErrCode errCode)
191 {
192 HILOGI("begin incremental restore on result report, bundleName:%{public}s", bundleName.c_str());
193 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onResultReport) {
194 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
195 return BError(BError::Codes::OK);
196 }
197 callbacksIncrementalRestore_.onResultReport(bundleName, result);
198 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) {
199 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
200 return BError(BError::Codes::OK);
201 }
202 callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName);
203 return BError(BError::Codes::OK);
204 }
205
IncrementalRestoreOnProcessInfo(const std::string & bundleName,const std::string & processInfo)206 ErrCode ServiceReverse::IncrementalRestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo)
207 {
208 HILOGI("begin incremental report processInfo, bundleName:%{public}s", bundleName.c_str());
209 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onProcess) {
210 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
211 return BError(BError::Codes::OK);
212 }
213 callbacksIncrementalRestore_.onProcess(bundleName, processInfo);
214 return BError(BError::Codes::OK);
215 }
216
ServiceReverse(BIncrementalBackupSession::Callbacks callbacks)217 ServiceReverse::ServiceReverse(BIncrementalBackupSession::Callbacks callbacks)
218 : scenario_(Scenario::BACKUP), callbacksIncrementalBackup_(callbacks)
219 {
220 }
221
ServiceReverse(BIncrementalRestoreSession::Callbacks callbacks)222 ServiceReverse::ServiceReverse(BIncrementalRestoreSession::Callbacks callbacks)
223 : scenario_(Scenario::RESTORE), callbacksIncrementalRestore_(callbacks)
224 {
225 }
226 } // namespace OHOS::FileManagement::Backup