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