1 /*
2 * Copyright (c) 2023 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 <string_ex.h>
17 #include "update_service_proxy.h"
18
19 #include "securec.h"
20
21 #include "message_parcel_helper.h"
22 #include "update_define.h"
23 #include "update_define.h"
24 #include "update_log.h"
25 #include "updater_sa_ipc_interface_code.h"
26
27 namespace OHOS::UpdateEngine {
28 #define RETURN_WHEN_REMOTE_NULL(remote) \
29 ENGINE_CHECK((remote) != nullptr, return INT_CALL_IPC_ERR, "Can not get remote")
30
31 #define IPC_RESULT_TO_CALL_RESULT(result) \
32 if ((result) == ERR_NONE) { \
33 result = INT_CALL_SUCCESS; \
34 } else if ((result) >= CALL_RESULT_OFFSET) { \
35 result = (result) - CALL_RESULT_OFFSET; \
36 } else { \
37 result = INT_CALL_IPC_ERR; \
38 }
39
40 #define RETURN_WHEN_TOKEN_WRITE_FAIL(data) \
41 if (!(data).WriteInterfaceToken(GetDescriptor())) { \
42 ENGINE_LOGE("UpdateServiceProxy WriteInterfaceToken fail"); \
43 return INT_CALL_IPC_ERR; \
44 }
45
46 #define RETURN_FAIL_WHEN_REMOTE_ERR(methodName, res) \
47 do { \
48 ENGINE_LOGI("%{public}s is %{public}d", methodName, res); \
49 IPC_RESULT_TO_CALL_RESULT(res); \
50 ENGINE_CHECK((res) == INT_CALL_SUCCESS, return (res), "Transact error"); \
51 } while (0)
52
RegisterUpdateCallback(const UpgradeInfo & info,const sptr<IUpdateCallback> & updateCallback)53 int32_t UpdateServiceProxy::RegisterUpdateCallback(const UpgradeInfo &info, const sptr<IUpdateCallback> &updateCallback)
54 {
55 ENGINE_CHECK(updateCallback != nullptr, return INT_PARAM_ERR, "Invalid param");
56 ENGINE_LOGI("UpdateServiceProxy::RegisterUpdateCallback");
57
58 auto remote = Remote();
59 RETURN_WHEN_REMOTE_NULL(remote);
60
61 MessageParcel data;
62 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
63 MessageParcelHelper::WriteUpgradeInfo(data, info);
64 bool res = data.WriteRemoteObject(updateCallback->AsObject());
65 ENGINE_CHECK(res, return INT_CALL_IPC_ERR, "RegisterUpdateCallback error, WriteRemoteObject fail");
66
67 MessageParcel reply;
68 MessageOption option;
69 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::REGISTER_CALLBACK), data, reply, option);
70 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::RegisterUpdateCallback", ret);
71 return INT_CALL_SUCCESS;
72 }
73
UnregisterUpdateCallback(const UpgradeInfo & info)74 int32_t UpdateServiceProxy::UnregisterUpdateCallback(const UpgradeInfo &info)
75 {
76 auto remote = Remote();
77 RETURN_WHEN_REMOTE_NULL(remote);
78
79 MessageParcel data;
80 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
81 MessageParcelHelper::WriteUpgradeInfo(data, info);
82
83 MessageParcel reply;
84 MessageOption option;
85 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::UNREGISTER_CALLBACK), data, reply, option);
86 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::UnregisterUpdateCallback", ret);
87 return INT_CALL_SUCCESS;
88 }
89
CheckNewVersion(const UpgradeInfo & info,BusinessError & businessError,CheckResult & checkResult)90 int32_t UpdateServiceProxy::CheckNewVersion(const UpgradeInfo &info, BusinessError &businessError,
91 CheckResult &checkResult)
92 {
93 ENGINE_LOGI("UpdateServiceProxy::CheckNewVersion");
94 auto remote = Remote();
95 RETURN_WHEN_REMOTE_NULL(remote);
96
97 MessageParcel data;
98 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
99 MessageParcelHelper::WriteUpgradeInfo(data, info);
100
101 MessageParcel reply;
102 MessageOption option;
103 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::CHECK_VERSION), data, reply, option);
104 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::CheckNewVersion", ret);
105 CheckResult result;
106 BusinessError error;
107 MessageParcelHelper::ReadBusinessError(reply, error);
108 MessageParcelHelper::ReadCheckResult(reply, result);
109 checkResult = result;
110 businessError = error;
111 return INT_CALL_SUCCESS;
112 }
113
Download(const UpgradeInfo & info,const VersionDigestInfo & versionDigestInfo,const DownloadOptions & downloadOptions,BusinessError & businessError)114 int32_t UpdateServiceProxy::Download(const UpgradeInfo &info, const VersionDigestInfo &versionDigestInfo,
115 const DownloadOptions &downloadOptions, BusinessError &businessError)
116 {
117 ENGINE_LOGI("UpdateServiceProxy::Download");
118 auto remote = Remote();
119 RETURN_WHEN_REMOTE_NULL(remote);
120
121 MessageParcel data;
122 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
123 MessageParcelHelper::WriteUpgradeInfo(data, info);
124 MessageParcelHelper::WriteVersionDigestInfo(data, versionDigestInfo);
125 MessageParcelHelper::WriteDownloadOptions(data, downloadOptions);
126
127 MessageParcel reply;
128 MessageOption option;
129 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::DOWNLOAD), data, reply, option);
130 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::Download", ret);
131 BusinessError remoteBusinessError;
132 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
133 businessError = remoteBusinessError;
134 return INT_CALL_SUCCESS;
135 }
136
PauseDownload(const UpgradeInfo & info,const VersionDigestInfo & versionDigestInfo,const PauseDownloadOptions & pauseDownloadOptions,BusinessError & businessError)137 int32_t UpdateServiceProxy::PauseDownload(const UpgradeInfo &info, const VersionDigestInfo &versionDigestInfo,
138 const PauseDownloadOptions &pauseDownloadOptions, BusinessError &businessError)
139 {
140 ENGINE_LOGI("UpdateServiceProxy::PauseDownload");
141 auto remote = Remote();
142 RETURN_WHEN_REMOTE_NULL(remote);
143
144 MessageParcel data;
145 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
146 MessageParcelHelper::WriteUpgradeInfo(data, info);
147 MessageParcelHelper::WriteVersionDigestInfo(data, versionDigestInfo);
148 MessageParcelHelper::WritePauseDownloadOptions(data, pauseDownloadOptions);
149
150 MessageParcel reply;
151 MessageOption option;
152 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::PAUSE_DOWNLOAD), data, reply, option);
153 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::ResumeDownload", ret);
154 BusinessError remoteBusinessError;
155 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
156 businessError = remoteBusinessError;
157 return INT_CALL_SUCCESS;
158 }
159
ResumeDownload(const UpgradeInfo & info,const VersionDigestInfo & versionDigestInfo,const ResumeDownloadOptions & resumeDownloadOptions,BusinessError & businessError)160 int32_t UpdateServiceProxy::ResumeDownload(const UpgradeInfo &info, const VersionDigestInfo &versionDigestInfo,
161 const ResumeDownloadOptions &resumeDownloadOptions, BusinessError &businessError)
162 {
163 ENGINE_LOGI("UpdateServiceProxy::ResumeDownload");
164 auto remote = Remote();
165 RETURN_WHEN_REMOTE_NULL(remote);
166
167 MessageParcel data;
168 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
169 MessageParcelHelper::WriteUpgradeInfo(data, info);
170 MessageParcelHelper::WriteVersionDigestInfo(data, versionDigestInfo);
171 MessageParcelHelper::WriteResumeDownloadOptions(data, resumeDownloadOptions);
172
173 MessageParcel reply;
174 MessageOption option;
175 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::RESUME_DOWNLOAD), data, reply, option);
176 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::ResumeDownload", ret);
177 BusinessError remoteBusinessError;
178 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
179 businessError = remoteBusinessError;
180 return INT_CALL_SUCCESS;
181 }
182
Upgrade(const UpgradeInfo & info,const VersionDigestInfo & versionDigest,const UpgradeOptions & upgradeOptions,BusinessError & businessError)183 int32_t UpdateServiceProxy::Upgrade(const UpgradeInfo &info, const VersionDigestInfo &versionDigest,
184 const UpgradeOptions &upgradeOptions, BusinessError &businessError)
185 {
186 ENGINE_LOGI("UpdateServiceProxy::Upgrade, versionDigest %{public}s upgradeOptions %{public}d",
187 versionDigest.versionDigest.c_str(),
188 upgradeOptions.order);
189 auto remote = Remote();
190 RETURN_WHEN_REMOTE_NULL(remote);
191
192 MessageParcel data;
193 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
194 MessageParcelHelper::WriteUpgradeInfo(data, info);
195 MessageParcelHelper::WriteVersionDigestInfo(data, versionDigest);
196 MessageParcelHelper::WriteUpgradeOptions(data, upgradeOptions);
197
198 MessageParcel reply;
199 MessageOption option;
200 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::UPGRADE), data, reply, option);
201 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::Upgrade", ret);
202 BusinessError remoteBusinessError;
203 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
204 businessError = remoteBusinessError;
205 return INT_CALL_SUCCESS;
206 }
207
ClearError(const UpgradeInfo & info,const VersionDigestInfo & versionDigest,const ClearOptions & clearOptions,BusinessError & businessError)208 int32_t UpdateServiceProxy::ClearError(const UpgradeInfo &info, const VersionDigestInfo &versionDigest,
209 const ClearOptions &clearOptions, BusinessError &businessError)
210 {
211 auto remote = Remote();
212 RETURN_WHEN_REMOTE_NULL(remote);
213
214 MessageParcel data;
215 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
216 MessageParcelHelper::WriteUpgradeInfo(data, info);
217 MessageParcelHelper::WriteVersionDigestInfo(data, versionDigest);
218 MessageParcelHelper::WriteClearOptions(data, clearOptions);
219
220 MessageParcel reply;
221 MessageOption option;
222 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::CLEAR_ERROR), data, reply, option);
223 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::ClearError", ret);
224 BusinessError remoteBusinessError;
225 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
226 businessError = remoteBusinessError;
227 return INT_CALL_SUCCESS;
228 }
229
TerminateUpgrade(const UpgradeInfo & info,BusinessError & businessError)230 int32_t UpdateServiceProxy::TerminateUpgrade(const UpgradeInfo &info, BusinessError &businessError)
231 {
232 auto remote = Remote();
233 RETURN_WHEN_REMOTE_NULL(remote);
234
235 MessageParcel data;
236 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
237 MessageParcelHelper::WriteUpgradeInfo(data, info);
238
239 MessageParcel reply;
240 MessageOption option;
241 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::TERMINATE_UPGRADE), data, reply, option);
242 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::TerminateUpgrade", ret);
243 BusinessError remoteBusinessError;
244 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
245 businessError = remoteBusinessError;
246 return INT_CALL_SUCCESS;
247 }
248
GetNewVersionInfo(const UpgradeInfo & info,NewVersionInfo & newVersionInfo,BusinessError & businessError)249 int32_t UpdateServiceProxy::GetNewVersionInfo(const UpgradeInfo &info, NewVersionInfo &newVersionInfo,
250 BusinessError &businessError)
251 {
252 ENGINE_LOGI("UpdateServiceProxy::GetNewVersionInfo");
253 auto remote = Remote();
254 RETURN_WHEN_REMOTE_NULL(remote);
255
256 MessageParcel data;
257 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
258 MessageParcelHelper::WriteUpgradeInfo(data, info);
259
260 MessageParcel reply;
261 MessageOption option;
262 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::GET_NEW_VERSION), data, reply, option);
263 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::GetNewVersionInfo", ret);
264
265 BusinessError remoteBusinessError;
266 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
267 businessError = remoteBusinessError;
268 NewVersionInfo remoteNewVersionInfo;
269 MessageParcelHelper::ReadNewVersionInfo(reply, remoteNewVersionInfo);
270 newVersionInfo = remoteNewVersionInfo;
271 return INT_CALL_SUCCESS;
272 }
273
GetNewVersionDescription(const UpgradeInfo & info,const VersionDigestInfo & versionDigestInfo,const DescriptionOptions & descriptionOptions,VersionDescriptionInfo & newVersionDescriptionInfo,BusinessError & businessError)274 int32_t UpdateServiceProxy::GetNewVersionDescription(const UpgradeInfo &info,
275 const VersionDigestInfo &versionDigestInfo, const DescriptionOptions &descriptionOptions,
276 VersionDescriptionInfo &newVersionDescriptionInfo, BusinessError &businessError)
277 {
278 ENGINE_LOGI("UpdateServiceProxy::GetNewVersionDescription");
279 auto remote = Remote();
280 RETURN_WHEN_REMOTE_NULL(remote);
281
282 MessageParcel data;
283 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
284 MessageParcelHelper::WriteUpgradeInfo(data, info);
285 MessageParcelHelper::WriteVersionDigestInfo(data, versionDigestInfo);
286 MessageParcelHelper::WriteDescriptionOptions(data, descriptionOptions);
287
288 MessageParcel reply;
289 MessageOption option;
290 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::GET_NEW_VERSION_DESCRIPTION),
291 data, reply, option);
292 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::GetNewVersionDescription", ret);
293
294 BusinessError remoteBusinessError;
295 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
296 businessError = remoteBusinessError;
297 VersionDescriptionInfo remoteVersionDescriptionInfo;
298 MessageParcelHelper::ReadVersionDescriptionInfo(reply, remoteVersionDescriptionInfo);
299 newVersionDescriptionInfo = remoteVersionDescriptionInfo;
300 return INT_CALL_SUCCESS;
301 }
302
GetCurrentVersionInfo(const UpgradeInfo & info,CurrentVersionInfo & currentVersionInfo,BusinessError & businessError)303 int32_t UpdateServiceProxy::GetCurrentVersionInfo(const UpgradeInfo &info, CurrentVersionInfo ¤tVersionInfo,
304 BusinessError &businessError)
305 {
306 ENGINE_LOGI("UpdateServiceProxy::GetCurrentVersionInfo");
307 auto remote = Remote();
308 RETURN_WHEN_REMOTE_NULL(remote);
309
310 MessageParcel data;
311 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
312 MessageParcelHelper::WriteUpgradeInfo(data, info);
313
314 MessageParcel reply;
315 MessageOption option;
316 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::GET_CURRENT_VERSION), data, reply, option);
317 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::GetCurrentVersionInfo", ret);
318
319 BusinessError remoteBusinessError;
320 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
321 businessError = remoteBusinessError;
322 CurrentVersionInfo remoteCurrentVersionInfo;
323 MessageParcelHelper::ReadCurrentVersionInfo(reply, remoteCurrentVersionInfo);
324 currentVersionInfo = remoteCurrentVersionInfo;
325 return INT_CALL_SUCCESS;
326 }
327
GetCurrentVersionDescription(const UpgradeInfo & info,const DescriptionOptions & descriptionOptions,VersionDescriptionInfo & currentVersionDescriptionInfo,BusinessError & businessError)328 int32_t UpdateServiceProxy::GetCurrentVersionDescription(const UpgradeInfo &info,
329 const DescriptionOptions &descriptionOptions, VersionDescriptionInfo ¤tVersionDescriptionInfo,
330 BusinessError &businessError)
331 {
332 ENGINE_LOGI("UpdateServiceProxy::GetCurrentVersionDescription");
333 auto remote = Remote();
334 RETURN_WHEN_REMOTE_NULL(remote);
335
336 MessageParcel data;
337 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
338 MessageParcelHelper::WriteUpgradeInfo(data, info);
339 MessageParcelHelper::WriteDescriptionOptions(data, descriptionOptions);
340
341 MessageParcel reply;
342 MessageOption option;
343 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::GET_CURRENT_VERSION_DESCRIPTION),
344 data, reply, option);
345 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::GetCurrentVersionDescription", ret);
346
347 BusinessError remoteBusinessError;
348 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
349 businessError = remoteBusinessError;
350 VersionDescriptionInfo remoteVersionDescriptionInfo;
351 MessageParcelHelper::ReadVersionDescriptionInfo(reply, remoteVersionDescriptionInfo);
352 currentVersionDescriptionInfo = remoteVersionDescriptionInfo;
353 return INT_CALL_SUCCESS;
354 }
355
GetTaskInfo(const UpgradeInfo & info,TaskInfo & taskInfo,BusinessError & businessError)356 int32_t UpdateServiceProxy::GetTaskInfo(const UpgradeInfo &info, TaskInfo &taskInfo, BusinessError &businessError)
357 {
358 ENGINE_LOGI("UpdateServiceProxy::GetTaskInfo");
359 auto remote = Remote();
360 RETURN_WHEN_REMOTE_NULL(remote);
361
362 MessageParcel data;
363 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
364 MessageParcelHelper::WriteUpgradeInfo(data, info);
365
366 MessageParcel reply;
367 MessageOption option;
368 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::GET_TASK_INFO), data, reply, option);
369 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::GetTaskInfo", ret);
370
371 BusinessError remoteBusinessError;
372 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
373 businessError = remoteBusinessError;
374 TaskInfo remoteTaskInfo;
375 MessageParcelHelper::ReadTaskInfo(reply, remoteTaskInfo);
376 taskInfo = remoteTaskInfo;
377 return INT_CALL_SUCCESS;
378 }
379
SetUpgradePolicy(const UpgradeInfo & info,const UpgradePolicy & policy,BusinessError & businessError)380 int32_t UpdateServiceProxy::SetUpgradePolicy(const UpgradeInfo &info, const UpgradePolicy &policy,
381 BusinessError &businessError)
382 {
383 ENGINE_LOGI("UpdateServiceProxy::SetUpgradePolicy");
384 auto remote = Remote();
385 RETURN_WHEN_REMOTE_NULL(remote);
386
387 MessageParcel data;
388 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
389 MessageParcelHelper::WriteUpgradeInfo(data, info);
390 MessageParcelHelper::WriteUpgradePolicy(data, policy);
391
392 MessageParcel reply;
393 MessageOption option;
394 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::SET_POLICY), data, reply, option);
395 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::SetUpgradePolicy", ret);
396
397 BusinessError remoteBusinessError;
398 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
399 businessError = remoteBusinessError;
400 return INT_CALL_SUCCESS;
401 }
402
GetUpgradePolicy(const UpgradeInfo & info,UpgradePolicy & policy,BusinessError & businessError)403 int32_t UpdateServiceProxy::GetUpgradePolicy(const UpgradeInfo &info, UpgradePolicy &policy,
404 BusinessError &businessError)
405 {
406 ENGINE_LOGI("UpdateServiceProxy::GetUpgradePolicy");
407 auto remote = Remote();
408 RETURN_WHEN_REMOTE_NULL(remote);
409
410 MessageParcel data;
411 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
412 MessageParcelHelper::WriteUpgradeInfo(data, info);
413
414 MessageParcel reply;
415 MessageOption option;
416 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::GET_POLICY), data, reply, option);
417 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::GetUpgradePolicy", ret);
418
419 BusinessError remoteBusinessError;
420 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
421 businessError = remoteBusinessError;
422 UpgradePolicy remoteUpgradePolicy;
423 MessageParcelHelper::ReadUpgradePolicy(reply, remoteUpgradePolicy);
424 policy = remoteUpgradePolicy;
425 return INT_CALL_SUCCESS;
426 }
427
Cancel(const UpgradeInfo & info,int32_t service,BusinessError & businessError)428 int32_t UpdateServiceProxy::Cancel(const UpgradeInfo &info, int32_t service, BusinessError &businessError)
429 {
430 ENGINE_LOGI("UpdateServiceProxy::Cancel");
431 auto remote = Remote();
432 RETURN_WHEN_REMOTE_NULL(remote);
433
434 MessageParcel data;
435 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
436 MessageParcelHelper::WriteUpgradeInfo(data, info);
437 data.WriteInt32(static_cast<int32_t>(service));
438
439 MessageParcel reply;
440 MessageOption option;
441 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::CANCEL), data, reply, option);
442 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::Cancel", ret);
443
444 BusinessError remoteBusinessError;
445 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
446 businessError = remoteBusinessError;
447 return INT_CALL_SUCCESS;
448 }
449
FactoryReset(BusinessError & businessError)450 int32_t UpdateServiceProxy::FactoryReset(BusinessError &businessError)
451 {
452 ENGINE_LOGI("UpdateServiceProxy::FactoryReset");
453 auto remote = Remote();
454 RETURN_WHEN_REMOTE_NULL(remote);
455
456 MessageParcel data;
457 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
458
459 MessageParcel reply;
460 MessageOption option;
461 int32_t ret = ERR_NONE; // IPC errCode: defined in ipc_types.h
462 #ifndef UPDATER_UT
463 ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::FACTORY_RESET), data, reply, option);
464 #endif
465 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::FactoryReset", ret);
466
467 BusinessError remoteBusinessError;
468 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
469 businessError = remoteBusinessError;
470 return INT_CALL_SUCCESS;
471 }
472
ApplyNewVersion(const UpgradeInfo & info,const std::string & miscFile,const std::vector<std::string> & packageNames,BusinessError & businessError)473 int32_t UpdateServiceProxy::ApplyNewVersion(const UpgradeInfo &info, const std::string &miscFile,
474 const std::vector<std::string> &packageNames, BusinessError &businessError)
475 {
476 ENGINE_LOGI("UpdateServiceProxy::ApplyNewVersion");
477 auto remote = Remote();
478 RETURN_WHEN_REMOTE_NULL(remote);
479
480 MessageParcel data;
481 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
482 MessageParcelHelper::WriteUpgradeInfo(data, info);
483 data.WriteString16(Str8ToStr16(miscFile));
484 data.WriteInt32(static_cast<int32_t>(packageNames.size()));
485 for (size_t i = 0; i < packageNames.size(); i++) {
486 data.WriteString16(Str8ToStr16(packageNames[i]));
487 }
488
489 MessageParcel reply;
490 MessageOption option;
491 int32_t ret = ERR_NONE;
492 #ifndef UPDATER_UT
493 ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::APPLY_NEW_VERSION), data, reply, option);
494 #endif
495 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::ApplyNewVersion", ret);
496
497 BusinessError remoteBusinessError;
498 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
499 businessError = remoteBusinessError;
500 return INT_CALL_SUCCESS;
501 }
502
VerifyUpgradePackage(const std::string & packagePath,const std::string & keyPath,BusinessError & businessError)503 int32_t UpdateServiceProxy::VerifyUpgradePackage(const std::string &packagePath, const std::string &keyPath,
504 BusinessError &businessError)
505 {
506 ENGINE_LOGI("UpdateServiceProxy::VerifyUpgradePackage");
507 auto remote = Remote();
508 RETURN_WHEN_REMOTE_NULL(remote);
509
510 MessageParcel data;
511 RETURN_WHEN_TOKEN_WRITE_FAIL(data);
512 data.WriteString16(Str8ToStr16(packagePath));
513 data.WriteString16(Str8ToStr16(keyPath));
514
515 MessageParcel reply;
516 MessageOption option;
517 int32_t ret = remote->SendRequest(CAST_UINT(UpdaterSaInterfaceCode::VERIFY_UPGRADE_PACKAGE), data, reply, option);
518 RETURN_FAIL_WHEN_REMOTE_ERR("UpdateServiceProxy::VerifyUpgradePackage", ret);
519
520 BusinessError remoteBusinessError;
521 MessageParcelHelper::ReadBusinessError(reply, remoteBusinessError);
522 businessError = remoteBusinessError;
523 return INT_CALL_SUCCESS;
524 }
525 } // namespace OHOS::UpdateEngine
526