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
IncrementalRestoreOnBundleStarted(int32_t errCode,string bundleName)84 void ServiceReverse::IncrementalRestoreOnBundleStarted(int32_t errCode, string bundleName)
85 {
86 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleStarted) {
87 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
88 return;
89 }
90 callbacksIncrementalRestore_.onBundleStarted(errCode, bundleName);
91 }
92
IncrementalRestoreOnBundleFinished(int32_t errCode,string bundleName)93 void ServiceReverse::IncrementalRestoreOnBundleFinished(int32_t errCode, string bundleName)
94 {
95 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) {
96 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
97 return;
98 }
99 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
100 callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName);
101 }
102
IncrementalRestoreOnAllBundlesFinished(int32_t errCode)103 void ServiceReverse::IncrementalRestoreOnAllBundlesFinished(int32_t errCode)
104 {
105 HILOGI("errCode = %{public}d", errCode);
106 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onAllBundlesFinished) {
107 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
108 return;
109 }
110 callbacksIncrementalRestore_.onAllBundlesFinished(errCode);
111 }
112
IncrementalRestoreOnFileReady(string bundleName,string fileName,int fd,int manifestFd,int32_t errCode)113 void ServiceReverse::IncrementalRestoreOnFileReady(string bundleName, string fileName, int fd, int manifestFd,
114 int32_t errCode)
115 {
116 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onFileReady) {
117 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
118 return;
119 }
120 BFileInfo bFileInfo(bundleName, fileName, 0);
121 callbacksIncrementalRestore_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode);
122 }
123
IncrementalRestoreOnResultReport(std::string result,std::string bundleName,ErrCode errCode)124 void ServiceReverse::IncrementalRestoreOnResultReport(std::string result, std::string bundleName, ErrCode errCode)
125 {
126 HILOGI("begin incremental restore on result report, bundleName:%{public}s", bundleName.c_str());
127 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onResultReport) {
128 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
129 return;
130 }
131 callbacksIncrementalRestore_.onResultReport(bundleName, result);
132 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) {
133 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
134 return;
135 }
136 callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName);
137 }
138
IncrementalRestoreOnProcessInfo(std::string bundleName,std::string processInfo)139 void ServiceReverse::IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo)
140 {
141 HILOGI("begin incremental report processInfo, bundleName:%{public}s", bundleName.c_str());
142 if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onProcess) {
143 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
144 return;
145 }
146 callbacksIncrementalRestore_.onProcess(bundleName, processInfo);
147 }
148
ServiceReverse(BIncrementalBackupSession::Callbacks callbacks)149 ServiceReverse::ServiceReverse(BIncrementalBackupSession::Callbacks callbacks)
150 : scenario_(Scenario::BACKUP), callbacksIncrementalBackup_(callbacks)
151 {
152 }
153
ServiceReverse(BIncrementalRestoreSession::Callbacks callbacks)154 ServiceReverse::ServiceReverse(BIncrementalRestoreSession::Callbacks callbacks)
155 : scenario_(Scenario::RESTORE), callbacksIncrementalRestore_(callbacks)
156 {
157 }
158 } // namespace OHOS::FileManagement::Backup