1 /*
2 * Copyright (c) 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 "update_client.h"
17
18 #include <thread>
19
20 #include "client_helper.h"
21 #include "napi_common_utils.h"
22 #include "update_service_kits.h"
23 #include "update_session.h"
24 #include "update_callback_info.h"
25 #include "updater_sa_ipc_interface_code.h"
26
27 using namespace std;
28
29 namespace OHOS::UpdateEngine {
NapiOn(napi_env env,napi_callback_info info)30 napi_value UpdateClient::Napi::NapiOn(napi_env env, napi_callback_info info)
31 {
32 ENGINE_LOGI("UpdateClient::Napi::NapiOn");
33 UpdateClient *updater = UnwrapJsObject<UpdateClient>(env, info);
34 PARAM_CHECK_NAPI_CALL(env, updater != nullptr, return nullptr, "Error get UpdateClient");
35 return updater->On(env, info);
36 }
37
NapiOff(napi_env env,napi_callback_info info)38 napi_value UpdateClient::Napi::NapiOff(napi_env env, napi_callback_info info)
39 {
40 ENGINE_LOGI("UpdateClient::Napi::NapiOff");
41 UpdateClient *updater = UnwrapJsObject<UpdateClient>(env, info);
42 PARAM_CHECK_NAPI_CALL(env, updater != nullptr, return nullptr, "Error get UpdateClient");
43 return updater->Off(env, info);
44 }
45
UpdateClient(napi_env env,napi_value thisVar)46 UpdateClient::UpdateClient(napi_env env, napi_value thisVar)
47 {
48 ENGINE_LOGI("UpdateClient::UpdateClient");
49 napi_ref thisReference = nullptr;
50 constexpr int32_t refCount = 1; // 新引用的初始引用计数
51 napi_create_reference(env, thisVar, refCount, &thisReference);
52 sessionsMgr_ = std::make_shared<SessionManager>(env, thisReference);
53 }
54
~UpdateClient()55 UpdateClient::~UpdateClient()
56 {
57 ENGINE_LOGI("UpdateClient::~UpdateClient");
58 }
59
GetOnlineUpdater(napi_env env,napi_callback_info info)60 napi_value UpdateClient::GetOnlineUpdater(napi_env env, napi_callback_info info)
61 {
62 napi_value result;
63 napi_create_int32(env, 0, &result);
64 size_t argc = MAX_ARGC;
65 napi_value args[MAX_ARGC] = { 0 };
66 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
67 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
68 std::vector<std::pair<std::string, std::string>> paramInfos;
69 paramInfos.push_back({ "upgradeInfo", "UpgradeInfo" });
70 PARAM_CHECK_NAPI_CALL(env, argc >= 1, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
71 return nullptr, "Invalid param");
72 PARAM_CHECK_NAPI_CALL(env, !isInit_, return result, "Has been init");
73
74 ClientStatus ret = ClientHelper::GetUpgradeInfoFromArg(env, args[0], upgradeInfo_);
75 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
76 return nullptr, "Failed to get upgradeInfo param");
77 isInit_ = true;
78 return result;
79 }
80
RegisterCallback()81 void UpdateClient::RegisterCallback()
82 {
83 ENGINE_LOGI("RegisterCallback");
84 UpdateCallbackInfo callback{ [=](const EventInfo &eventInfo) { NotifyEventInfo(eventInfo); } };
85 constexpr int32_t sleepDuration = 10; // 回调注册失败后再次尝试之前的等待时间，单位：毫秒
86 constexpr int32_t maxRetryTimes = 5; // 回调注册失败最大尝试次数
87 int32_t retryTimes = 0;
88 do {
89 int32_t ret = UpdateServiceKits::GetInstance().RegisterUpdateCallback(upgradeInfo_, callback);
90 if (ret == INT_CALL_SUCCESS) {
91 break;
92 }
93
94 if (retryTimes++ < maxRetryTimes) {
95 ENGINE_LOGI("InitCallback fail, will retry after %{public}d milliseconds", sleepDuration);
96 std::this_thread::sleep_for(std::chrono::milliseconds(sleepDuration));
97 } else {
98 ENGINE_LOGE("InitCallback fail after retry %{public}d times", retryTimes);
99 }
100 } while (retryTimes < maxRetryTimes);
101 }
102
103
UnRegisterCallback()104 void UpdateClient::UnRegisterCallback()
105 {
106 UpdateServiceKits::GetInstance().UnregisterUpdateCallback(upgradeInfo_);
107 }
108
CheckNewVersion(napi_env env,napi_callback_info info)109 napi_value UpdateClient::CheckNewVersion(napi_env env, napi_callback_info info)
110 {
111 SessionParams sessionParams(SessionType::SESSION_CHECK_VERSION, CALLBACK_POSITION_ONE, true);
112 napi_value ret = StartSession(env, info, sessionParams, [=](void *context) -> int {
113 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
114 return UpdateServiceKits::GetInstance().CheckNewVersion(upgradeInfo_, *businessError, checkResult_);
115 });
116 PARAM_CHECK(ret != nullptr, return nullptr, "Failed to start worker.");
117 return ret;
118 }
119
CancelUpgrade(napi_env env,napi_callback_info info)120 napi_value UpdateClient::CancelUpgrade(napi_env env, napi_callback_info info)
121 {
122 ENGINE_LOGI("CancelUpgrade");
123 SessionParams sessionParams(SessionType::SESSION_CANCEL_UPGRADE, CALLBACK_POSITION_ONE, true);
124 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
125 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
126 return UpdateServiceKits::GetInstance().Cancel(upgradeInfo_, CAST_INT(UpdaterSaInterfaceCode::DOWNLOAD),
127 *businessError);
128 });
129 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
130 return retValue;
131 }
132
133 template <typename T>
ParseUpgOptions(napi_env env,napi_callback_info info,VersionDigestInfo & versionDigestInfo,T & options)134 ClientStatus UpdateClient::ParseUpgOptions(napi_env env, napi_callback_info info, VersionDigestInfo &versionDigestInfo,
135 T &options)
136 {
137 size_t argc = MAX_ARGC;
138 napi_value args[MAX_ARGC] = { 0 };
139 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
140 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return ClientStatus::CLIENT_INVALID_PARAM, "Error get cb info");
141
142 ClientStatus ret = ClientHelper::GetVersionDigestInfoFromArg(env, args[0], versionDigestInfo);
143 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, return ClientStatus::CLIENT_INVALID_PARAM,
144 "Failed to get versionDigestInfo param");
145
146 ret = ClientHelper::GetOptionsFromArg(env, args[1], options);
147 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, return ClientStatus::CLIENT_INVALID_PARAM,
148 "Failed to get Options param");
149 return ClientStatus::CLIENT_SUCCESS;
150 }
151
ParseUpgOptions(napi_env env,napi_callback_info info,T & options)152 template <typename T> ClientStatus UpdateClient::ParseUpgOptions(napi_env env, napi_callback_info info, T &options)
153 {
154 size_t argc = MAX_ARGC;
155 napi_value args[MAX_ARGC] = { 0 };
156 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
157 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return ClientStatus::CLIENT_INVALID_PARAM, "Error get cb info");
158
159 ClientStatus ret = ClientHelper::GetOptionsFromArg(env, args[0], options);
160 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, return ClientStatus::CLIENT_INVALID_PARAM,
161 "Failed to get Options param");
162 return ClientStatus::CLIENT_SUCCESS;
163 }
164
Download(napi_env env,napi_callback_info info)165 napi_value UpdateClient::Download(napi_env env, napi_callback_info info)
166 {
167 size_t argc = MAX_ARGC;
168 napi_value args[MAX_ARGC] = { 0 };
169 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
170 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
171 ENGINE_LOGI("Download");
172
173 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, downloadOptions_);
174 std::vector<std::pair<std::string, std::string>> paramInfos;
175 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
176 paramInfos.push_back({ "downloadOptions", "DownloadOptions" });
177 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
178 return nullptr, "Failed to get Download param");
179
180 SessionParams sessionParams(SessionType::SESSION_DOWNLOAD, CALLBACK_POSITION_THREE, true);
181 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
182 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
183 return UpdateServiceKits::GetInstance().Download(upgradeInfo_, versionDigestInfo_, downloadOptions_,
184 *businessError);
185 });
186 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
187 return retValue;
188 }
189
PauseDownload(napi_env env,napi_callback_info info)190 napi_value UpdateClient::PauseDownload(napi_env env, napi_callback_info info)
191 {
192 size_t argc = MAX_ARGC;
193 napi_value args[MAX_ARGC] = { 0 };
194 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
195 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
196
197 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, pauseDownloadOptions_);
198 std::vector<std::pair<std::string, std::string>> paramInfos;
199 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
200 paramInfos.push_back({ "pauseDownloadOptions", "PauseDownloadOptions" });
201 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
202 return nullptr, "Failed to get pauseDownloadOptions param");
203
204 SessionParams sessionParams(SessionType::SESSION_PAUSE_DOWNLOAD, CALLBACK_POSITION_THREE, true);
205 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
206 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
207 return UpdateServiceKits::GetInstance().PauseDownload(upgradeInfo_, versionDigestInfo_, pauseDownloadOptions_,
208 *businessError);
209 });
210 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
211 return retValue;
212 }
213
ResumeDownload(napi_env env,napi_callback_info info)214 napi_value UpdateClient::ResumeDownload(napi_env env, napi_callback_info info)
215 {
216 size_t argc = MAX_ARGC;
217 napi_value args[MAX_ARGC] = { 0 };
218 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
219 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
220
221 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, resumeDownloadOptions_);
222 std::vector<std::pair<std::string, std::string>> paramInfos;
223 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
224 paramInfos.push_back({ "resumeDownloadOptions", "ResumeDownloadOptions" });
225 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
226 return nullptr, "Failed to get resumeDownloadOptions param");
227
228 SessionParams sessionParams(SessionType::SESSION_RESUME_DOWNLOAD, CALLBACK_POSITION_THREE, true);
229 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
230 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
231 return UpdateServiceKits::GetInstance().ResumeDownload(upgradeInfo_, versionDigestInfo_, resumeDownloadOptions_,
232 *businessError);
233 });
234 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
235 return retValue;
236 }
237
Upgrade(napi_env env,napi_callback_info info)238 napi_value UpdateClient::Upgrade(napi_env env, napi_callback_info info)
239 {
240 size_t argc = MAX_ARGC;
241 napi_value args[MAX_ARGC] = { 0 };
242 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
243 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
244
245 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, upgradeOptions_);
246 std::vector<std::pair<std::string, std::string>> paramInfos;
247 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
248 paramInfos.push_back({ "upgradeOptions", "UpgradeOptions" });
249 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
250 return nullptr, "Failed to get upgradeOptions param");
251
252 SessionParams sessionParams(SessionType::SESSION_UPGRADE, CALLBACK_POSITION_THREE, true);
253 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
254 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
255 return UpdateServiceKits::GetInstance().Upgrade(upgradeInfo_, versionDigestInfo_, upgradeOptions_,
256 *businessError);
257 });
258 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
259 return retValue;
260 }
261
ClearError(napi_env env,napi_callback_info info)262 napi_value UpdateClient::ClearError(napi_env env, napi_callback_info info)
263 {
264 size_t argc = MAX_ARGC;
265 napi_value args[MAX_ARGC] = { 0 };
266 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
267 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
268
269 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, clearOptions_);
270 std::vector<std::pair<std::string, std::string>> paramInfos;
271 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
272 paramInfos.push_back({ "clearOptions", "ClearOptions" });
273 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
274 return nullptr, "Failed to get clearOptions param");
275
276 SessionParams sessionParams(SessionType::SESSION_CLEAR_ERROR, CALLBACK_POSITION_THREE, true);
277 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
278 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
279 return UpdateServiceKits::GetInstance().ClearError(upgradeInfo_, versionDigestInfo_, clearOptions_,
280 *businessError);
281 });
282 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
283 return retValue;
284 }
285
TerminateUpgrade(napi_env env,napi_callback_info info)286 napi_value UpdateClient::TerminateUpgrade(napi_env env, napi_callback_info info)
287 {
288 size_t argc = MAX_ARGC;
289 napi_value args[MAX_ARGC] = { 0 };
290 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
291 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
292
293 SessionParams sessionParams(SessionType::SESSION_TERMINATE_UPGRADE, CALLBACK_POSITION_ONE, true);
294 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
295 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
296 return UpdateServiceKits::GetInstance().TerminateUpgrade(upgradeInfo_, *businessError);
297 });
298 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
299 return retValue;
300 }
301
SetUpgradePolicy(napi_env env,napi_callback_info info)302 napi_value UpdateClient::SetUpgradePolicy(napi_env env, napi_callback_info info)
303 {
304 size_t argc = MAX_ARGC;
305 napi_value args[MAX_ARGC] = { 0 };
306 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
307 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
308
309 ClientStatus ret = ClientHelper::GetUpgradePolicyFromArg(env, args[0], upgradePolicy_);
310 std::vector<std::pair<std::string, std::string>> paramInfos;
311 paramInfos.push_back({ "upgradePolicy", "UpgradePolicy" });
312 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
313 return nullptr, "Failed to get upgradePolicy param");
314
315 SessionParams sessionParams(SessionType::SESSION_SET_POLICY, CALLBACK_POSITION_TWO, true);
316 napi_value retValue = StartSession(env, info, sessionParams, [&](void *context) -> int {
317 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
318 return UpdateServiceKits::GetInstance().SetUpgradePolicy(upgradeInfo_, upgradePolicy_, *businessError);
319 });
320 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to SetUpgradePolicy.");
321 return retValue;
322 }
323
GetUpgradePolicy(napi_env env,napi_callback_info info)324 napi_value UpdateClient::GetUpgradePolicy(napi_env env, napi_callback_info info)
325 {
326 SessionParams sessionParams(SessionType::SESSION_GET_POLICY, CALLBACK_POSITION_ONE, true);
327 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
328 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
329 return UpdateServiceKits::GetInstance().GetUpgradePolicy(upgradeInfo_, upgradePolicy_, *businessError);
330 });
331 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to UpgradeVersion.");
332 return retValue;
333 }
334
GetNewVersionInfo(napi_env env,napi_callback_info info)335 napi_value UpdateClient::GetNewVersionInfo(napi_env env, napi_callback_info info)
336 {
337 SessionParams sessionParams(SessionType::SESSION_GET_NEW_VERSION, CALLBACK_POSITION_ONE, true);
338 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
339 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
340 return UpdateServiceKits::GetInstance().GetNewVersionInfo(upgradeInfo_, newVersionInfo_, *businessError);
341 });
342 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to GetNewVersionInfo.");
343 return retValue;
344 }
345
GetNewVersionDescription(napi_env env,napi_callback_info info)346 napi_value UpdateClient::GetNewVersionDescription(napi_env env, napi_callback_info info)
347 {
348 size_t argc = MAX_ARGC;
349 napi_value args[MAX_ARGC] = { 0 };
350 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
351 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
352 ENGINE_LOGI("GetNewVersionDescription");
353
354 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, descriptionOptions_);
355 std::vector<std::pair<std::string, std::string>> paramInfos;
356 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
357 paramInfos.push_back({ "descriptionOptions", "DescriptionOptions" });
358 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
359 return nullptr, "Failed to get descriptionOptions param");
360
361 SessionParams sessionParams(SessionType::SESSION_GET_NEW_VERSION_DESCRIPTION, CALLBACK_POSITION_THREE, true);
362 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
363 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
364 return UpdateServiceKits::GetInstance().GetNewVersionDescription(upgradeInfo_, versionDigestInfo_,
365 descriptionOptions_, newVersionDescriptionInfo_, *businessError);
366 });
367 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
368 return retValue;
369 }
370
GetCurrentVersionInfo(napi_env env,napi_callback_info info)371 napi_value UpdateClient::GetCurrentVersionInfo(napi_env env, napi_callback_info info)
372 {
373 SessionParams sessionParams(SessionType::SESSION_GET_CUR_VERSION, CALLBACK_POSITION_ONE, true);
374 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
375 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
376 return UpdateServiceKits::GetInstance().GetCurrentVersionInfo(upgradeInfo_, currentVersionInfo_,
377 *businessError);
378 });
379 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to GetCurrentVersionInfo.");
380 return retValue;
381 }
382
GetCurrentVersionDescription(napi_env env,napi_callback_info info)383 napi_value UpdateClient::GetCurrentVersionDescription(napi_env env, napi_callback_info info)
384 {
385 size_t argc = MAX_ARGC;
386 napi_value args[MAX_ARGC] = { 0 };
387 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
388 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
389 ENGINE_LOGI("GetCurrentVersionDescription");
390
391 ClientStatus ret = ParseUpgOptions(env, info, descriptionOptions_);
392 std::vector<std::pair<std::string, std::string>> paramInfos;
393 paramInfos.push_back({ "descriptionOptions", "DescriptionOptions" });
394 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
395 return nullptr, "Failed to get descriptionOptions param");
396
397 SessionParams sessionParams(SessionType::SESSION_GET_CUR_VERSION_DESCRIPTION, CALLBACK_POSITION_TWO, true);
398 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
399 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
400 return UpdateServiceKits::GetInstance().GetCurrentVersionDescription(upgradeInfo_, descriptionOptions_,
401 currentVersionDescriptionInfo_, *businessError);
402 });
403 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
404 return retValue;
405 }
406
GetTaskInfo(napi_env env,napi_callback_info info)407 napi_value UpdateClient::GetTaskInfo(napi_env env, napi_callback_info info)
408 {
409 SessionParams sessionParams(SessionType::SESSION_GET_TASK_INFO, CALLBACK_POSITION_ONE, true);
410 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
411 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
412 return UpdateServiceKits::GetInstance().GetTaskInfo(upgradeInfo_, taskInfo_, *businessError);
413 });
414 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to GetTaskInfo.");
415 return retValue;
416 }
417
GetUpdateResult(uint32_t type,UpdateResult & result)418 void UpdateClient::GetUpdateResult(uint32_t type, UpdateResult &result)
419 {
420 ENGINE_LOGI("GetUpdateResult type %{public}d", type);
421 result.type = type;
422 switch (type) {
423 case SessionType::SESSION_CHECK_VERSION:
424 result.result.checkResult = &checkResult_;
425 result.buildJSObject = ClientHelper::BuildCheckResult;
426 break;
427 case SessionType::SESSION_GET_NEW_VERSION:
428 result.result.newVersionInfo = &newVersionInfo_;
429 result.buildJSObject = ClientHelper::BuildNewVersionInfo;
430 break;
431 case SessionType::SESSION_GET_NEW_VERSION_DESCRIPTION:
432 result.result.versionDescriptionInfo = &newVersionDescriptionInfo_;
433 result.buildJSObject = ClientHelper::BuildVersionDescriptionInfo;
434 break;
435 case SessionType::SESSION_GET_TASK_INFO:
436 result.result.taskInfo = &taskInfo_;
437 result.buildJSObject = ClientHelper::BuildTaskInfo;
438 break;
439 case SessionType::SESSION_GET_CUR_VERSION:
440 result.result.currentVersionInfo = ¤tVersionInfo_;
441 result.buildJSObject = ClientHelper::BuildCurrentVersionInfo;
442 break;
443 case SessionType::SESSION_GET_CUR_VERSION_DESCRIPTION:
444 result.result.versionDescriptionInfo = ¤tVersionDescriptionInfo_;
445 result.buildJSObject = ClientHelper::BuildVersionDescriptionInfo;
446 break;
447 case SessionType::SESSION_GET_POLICY:
448 result.result.upgradePolicy = &upgradePolicy_;
449 result.buildJSObject = ClientHelper::BuildUpgradePolicy;
450 break;
451 default:
452 result.buildJSObject = ClientHelper::BuildUndefinedStatus;
453 break;
454 }
455 }
456 } // namespace OHOS::UpdateEngine