1 /*
2 * Copyright (c) 2025 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 "b_incremental_backup_session.h"
17
18 #include "b_error/b_error.h"
19 #include "b_radar/b_radar.h"
20 #include "filemgmt_libhilog.h"
21 #include "service_client.h"
22 #include "service_reverse.h"
23
24 namespace OHOS::FileManagement::Backup {
25 using namespace std;
26
~BIncrementalBackupSession()27 BIncrementalBackupSession::~BIncrementalBackupSession()
28 {
29 HILOGE("BIncrementalBackupSession Destory");
30 deathRecipient_ = nullptr;
31 }
32
Init(Callbacks callbacks)33 unique_ptr<BIncrementalBackupSession> BIncrementalBackupSession::Init(Callbacks callbacks)
34 {
35 try {
36 HILOGI("Init IncrementalBackupSession Begin");
37 auto backup = make_unique<BIncrementalBackupSession>();
38 ServiceClient::InvaildInstance();
39 auto proxy = ServiceClient::GetInstance();
40 if (proxy == nullptr) {
41 HILOGI("Failed to get backup service");
42 return nullptr;
43 }
44
45 int32_t res = proxy->InitIncrementalBackupSession(sptr(new ServiceReverse(callbacks)));
46 if (res != ERR_OK) {
47 HILOGE("Failed to Backup because of %{public}d", res);
48 AppRadar::Info info("", "", "");
49 AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::Init",
50 AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_CREATE_BACKUP_SESSION_FAIL, res);
51 return nullptr;
52 }
53
54 backup->RegisterBackupServiceDied(callbacks.onBackupServiceDied);
55 return backup;
56 } catch (const exception &e) {
57 HILOGE("Failed to Backup because of %{public}s", e.what());
58 }
59 return nullptr;
60 }
61
Init(Callbacks callbacks,std::string & errMsg,ErrCode & errCode)62 unique_ptr<BIncrementalBackupSession> BIncrementalBackupSession::Init(Callbacks callbacks,
63 std::string &errMsg, ErrCode &errCode)
64 {
65 try {
66 HILOGI("Init IncrementalBackupSession Begin");
67 auto backup = make_unique<BIncrementalBackupSession>();
68 ServiceClient::InvaildInstance();
69 auto proxy = ServiceClient::GetInstance();
70 if (proxy == nullptr) {
71 HILOGI("Failed to get backup service");
72 return nullptr;
73 }
74 proxy->InitIncrementalBackupSessionWithErrMsg(sptr(new ServiceReverse(callbacks)), errCode, errMsg);
75 if (errCode != ERR_OK) {
76 HILOGE("Failed to Backup because of %{public}d, %{public}s", errCode, errMsg.c_str());
77 AppRadar::Info info("", "", "");
78 AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::Init",
79 AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_CREATE_BACKUP_SESSION_FAIL, errCode);
80 return nullptr;
81 }
82 backup->RegisterBackupServiceDied(callbacks.onBackupServiceDied);
83 return backup;
84 } catch (const exception &e) {
85 HILOGE("Failed to Backup because of %{public}s", e.what());
86 errCode = BError(BError::Codes::SDK_INVAL_ARG);
87 }
88 return nullptr;
89 }
90
RegisterBackupServiceDied(function<void ()> functor)91 void BIncrementalBackupSession::RegisterBackupServiceDied(function<void()> functor)
92 {
93 auto proxy = ServiceClient::GetInstance();
94 if (proxy == nullptr || !functor) {
95 return;
96 }
97 auto remoteObj = proxy->AsObject();
98 if (!remoteObj) {
99 throw BError(BError::Codes::SA_BROKEN_IPC, "Proxy's remote object can't be nullptr");
100 }
101
102 auto callback = [functor](const wptr<IRemoteObject> &obj) {
103 ServiceClient::InvaildInstance();
104 HILOGI("Backup service died");
105 functor();
106 };
107 deathRecipient_ = sptr(new SvcDeathRecipient(callback));
108 remoteObj->AddDeathRecipient(deathRecipient_);
109 }
110
GetLocalCapabilities()111 UniqueFd BIncrementalBackupSession::GetLocalCapabilities()
112 {
113 HILOGI("GetLocalCapabilities begin");
114 auto proxy = ServiceClient::GetInstance();
115 if (proxy == nullptr) {
116 HILOGE("Failed to get backup service");
117 return UniqueFd(-EPERM);
118 }
119 int fdvalue = INVALID_FD;
120 proxy->GetLocalCapabilitiesForBundleInfos(fdvalue);
121 UniqueFd fd(fdvalue);
122 if (fd < 0) {
123 HILOGE("Failed to get local capabilities for bundleinfos");
124 return UniqueFd(-EPERM);
125 }
126 return fd;
127 }
128
GetBackupDataSize(bool isPreciseScan,vector<BIncrementalData> bundleNameList)129 ErrCode BIncrementalBackupSession::GetBackupDataSize(bool isPreciseScan, vector<BIncrementalData> bundleNameList)
130 {
131 HILOGI("GetBackupDataSize Begin");
132 auto proxy = ServiceClient::GetInstance();
133 if (proxy == nullptr) {
134 HILOGE("Failed to get backup service");
135 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
136 }
137 ErrCode err = proxy->GetBackupDataSize(isPreciseScan, bundleNameList);
138 if (err != ERR_OK) {
139 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to GetBackupDataSize").GetCode();
140 }
141 HILOGI("GetBackupDataSize end");
142 return ERR_OK;
143 }
144
AppendBundles(vector<BIncrementalData> bundlesToBackup)145 ErrCode BIncrementalBackupSession::AppendBundles(vector<BIncrementalData> bundlesToBackup)
146 {
147 auto proxy = ServiceClient::GetInstance();
148 if (proxy == nullptr) {
149 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
150 }
151
152 ErrCode res = proxy->AppendBundlesIncrementalBackupSession(bundlesToBackup);
153 if (res != ERR_OK) {
154 std::string ss;
155 for (const auto &bundle : bundlesToBackup) {
156 ss += bundle.bundleName + ", ";
157 }
158 AppRadar::Info info(ss.c_str(), "", "");
159 AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::AppendBundles",
160 AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, res);
161 }
162 return res;
163 }
164
AppendBundles(vector<BIncrementalData> bundlesToBackup,std::vector<std::string> infos)165 ErrCode BIncrementalBackupSession::AppendBundles(vector<BIncrementalData> bundlesToBackup,
166 std::vector<std::string> infos)
167 {
168 auto proxy = ServiceClient::GetInstance();
169 if (proxy == nullptr) {
170 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
171 }
172
173 int32_t res = proxy->AppendBundlesIncrementalBackupSessionWithBundleInfos(bundlesToBackup, infos);
174 if (res != ERR_OK) {
175 std::string ss;
176 for (const auto &bundle : bundlesToBackup) {
177 ss += bundle.bundleName + ", ";
178 }
179 AppRadar::Info info(ss.c_str(), "", "AppendBundles with infos");
180 AppRadar::GetInstance().RecordBackupFuncRes(info, "BIncrementalBackupSession::AppendBundles",
181 AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, res);
182 }
183 return res;
184 }
185
Release()186 ErrCode BIncrementalBackupSession::Release()
187 {
188 auto proxy = ServiceClient::GetInstance();
189 if (proxy == nullptr) {
190 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
191 }
192
193 return proxy->Release();
194 }
195
Cancel(std::string bundleName)196 ErrCode BIncrementalBackupSession::Cancel(std::string bundleName)
197 {
198 ErrCode result = BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK;
199 auto proxy = ServiceClient::GetInstance();
200 if (proxy == nullptr) {
201 HILOGE("Called Cancel, failed to get proxy.");
202 return result;
203 }
204
205 proxy->CancelForResult(bundleName, result);
206 return result;
207 }
208
CleanBundleTempDir(const std::string & bundleName)209 ErrCode BIncrementalBackupSession::CleanBundleTempDir(const std::string &bundleName)
210 {
211 HILOGI("BIncrementalBackupSession::CleanBundleTempDir");
212 auto proxy = ServiceClient::GetInstance();
213 if (proxy == nullptr) {
214 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
215 }
216 return proxy->CleanBundleTempDir(bundleName);
217 }
218
GetCompatibilityInfo(const std::string & bundleName,const std::string & extInfo,std::string & compatInfo)219 ErrCode BIncrementalBackupSession::GetCompatibilityInfo(const std::string &bundleName, const std::string &extInfo,
220 std::string &compatInfo)
221 {
222 HILOGI("BIncrementalBackupSession::GetCompatibilityInfo");
223 auto proxy = ServiceClient::GetInstance();
224 if (proxy == nullptr) {
225 return BError(BError::Codes::SDK_BROKEN_IPC, "Failed to get backup service").GetCode();
226 }
227 return proxy->GetCompatibilityInfo(bundleName, extInfo, compatInfo);
228 }
229 } // namespace OHOS::FileManagement::Backup