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