1 /*
2 * Copyright (c) 2022-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 "filemgmt_libhilog.h"
20
21 namespace OHOS::FileManagement::Backup {
22 using namespace std;
23
BackupOnFileReady(string bundleName,string fileName,int fd,int32_t errCode)24 void ServiceReverse::BackupOnFileReady(string bundleName, string fileName, int fd, int32_t errCode)
25 {
26 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onFileReady) {
27 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
28 return;
29 }
30 BFileInfo bFileInfo(bundleName, fileName, 0);
31 callbacksBackup_.onFileReady(bFileInfo, UniqueFd(fd), errCode);
32 }
33
BackupOnBundleStarted(int32_t errCode,string bundleName)34 void ServiceReverse::BackupOnBundleStarted(int32_t errCode, string bundleName)
35 {
36 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBundleStarted) {
37 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
38 return;
39 }
40 callbacksBackup_.onBundleStarted(errCode, bundleName);
41 }
42
BackupOnResultReport(std::string result,std::string bundleName)43 void ServiceReverse::BackupOnResultReport(std::string result, std::string bundleName)
44 {
45 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onResultReport) {
46 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
47 return;
48 }
49 callbacksBackup_.onResultReport(bundleName, result);
50 }
51
BackupOnBundleFinished(int32_t errCode,string bundleName)52 void ServiceReverse::BackupOnBundleFinished(int32_t errCode, string bundleName)
53 {
54 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBundleFinished) {
55 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
56 return;
57 }
58 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
59 callbacksBackup_.onBundleFinished(errCode, bundleName);
60 }
61
BackupOnAllBundlesFinished(int32_t errCode)62 void ServiceReverse::BackupOnAllBundlesFinished(int32_t errCode)
63 {
64 HILOGI("errCode = %{public}d", errCode);
65 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onAllBundlesFinished) {
66 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
67 return;
68 }
69 callbacksBackup_.onAllBundlesFinished(errCode);
70 }
71
BackupOnProcessInfo(std::string bundleName,std::string processInfo)72 void ServiceReverse::BackupOnProcessInfo(std::string bundleName, std::string processInfo)
73 {
74 HILOGI("bundleName = %{public}s", bundleName.c_str());
75 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onProcess) {
76 HILOGI("Error scenario or callback is nullptr");
77 return;
78 }
79 callbacksBackup_.onProcess(bundleName, processInfo);
80 }
81
BackupOnScanningInfo(std::string scannedInfo)82 void ServiceReverse::BackupOnScanningInfo(std::string scannedInfo)
83 {
84 if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBackupSizeReport) {
85 HILOGE("Error scenario or callback is nullptr");
86 return;
87 }
88 callbacksBackup_.onBackupSizeReport(scannedInfo);
89 }
90
RestoreOnBundleStarted(int32_t errCode,string bundleName)91 void ServiceReverse::RestoreOnBundleStarted(int32_t errCode, string bundleName)
92 {
93 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onBundleStarted) {
94 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
95 return;
96 }
97 callbacksRestore_.onBundleStarted(errCode, bundleName);
98 }
99
RestoreOnBundleFinished(int32_t errCode,string bundleName)100 void ServiceReverse::RestoreOnBundleFinished(int32_t errCode, string bundleName)
101 {
102 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onBundleFinished) {
103 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
104 return;
105 }
106 HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str());
107 callbacksRestore_.onBundleFinished(errCode, bundleName);
108 }
109
RestoreOnAllBundlesFinished(int32_t errCode)110 void ServiceReverse::RestoreOnAllBundlesFinished(int32_t errCode)
111 {
112 HILOGI("errCode = %{public}d", errCode);
113 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onAllBundlesFinished) {
114 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
115 return;
116 }
117 callbacksRestore_.onAllBundlesFinished(errCode);
118 }
119
RestoreOnFileReady(string bundleName,string fileName,int fd,int32_t errCode)120 void ServiceReverse::RestoreOnFileReady(string bundleName, string fileName, int fd, int32_t errCode)
121 {
122 HILOGD("begin, bundleName is:%{public}s", bundleName.c_str());
123 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onFileReady) {
124 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
125 return;
126 }
127 BFileInfo bFileInfo(bundleName, fileName, 0);
128 callbacksRestore_.onFileReady(bFileInfo, UniqueFd(fd), errCode);
129 }
130
RestoreOnResultReport(string result,std::string bundleName,ErrCode errCode)131 void ServiceReverse::RestoreOnResultReport(string result, std::string bundleName, ErrCode errCode)
132 {
133 HILOGI("ServiceReverse RestoreOnResultReport bundle %{public}s begin with result: %{public}s", bundleName.c_str(),
134 result.c_str());
135 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onResultReport) {
136 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
137 return;
138 }
139 callbacksRestore_.onResultReport(bundleName, result);
140 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onBundleFinished) {
141 HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_);
142 return;
143 }
144 callbacksRestore_.onBundleFinished(errCode, bundleName);
145 }
146
RestoreOnProcessInfo(std::string bundleName,std::string processInfo)147 void ServiceReverse::RestoreOnProcessInfo(std::string bundleName, std::string processInfo)
148 {
149 HILOGI("bundleName = %{public}s", bundleName.c_str());
150 if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onProcess) {
151 HILOGI("Error scenario or callback is nullptr");
152 return;
153 }
154 callbacksRestore_.onProcess(bundleName, processInfo);
155 }
156
ServiceReverse(BSessionBackup::Callbacks callbacks)157 ServiceReverse::ServiceReverse(BSessionBackup::Callbacks callbacks)
158 : scenario_(Scenario::BACKUP), callbacksBackup_(callbacks)
159 {
160 }
161
ServiceReverse(BSessionRestore::Callbacks callbacks)162 ServiceReverse::ServiceReverse(BSessionRestore::Callbacks callbacks)
163 : scenario_(Scenario::RESTORE), callbacksRestore_(callbacks)
164 {
165 }
166 } // namespace OHOS::FileManagement::Backup