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_helper.h"
23 #include "update_service_kits.h"
24 #include "update_session.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 size_t argc = MAX_ARGC;
123 napi_value args[MAX_ARGC] = { 0 };
124 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
125 PARAM_CHECK_NAPI_CALL(env, status == napi_ok && argc == 0, return nullptr, "Error get cb info");
126 ENGINE_LOGI("CancelUpgrade");
127 SessionParams sessionParams(SessionType::SESSION_CANCEL_UPGRADE, CALLBACK_POSITION_ONE, true);
128 std::shared_ptr<BaseSession> sess = nullptr;
129 sess = std::make_shared<UpdateAsyncessionNoCallback>(this, sessionParams, argc);
130 PARAM_CHECK_NAPI_CALL(env, sess != nullptr, return nullptr, "Failed to create update session");
131 sessionsMgr_->AddSession(sess);
132 napi_value retValue = sess->StartWork(
133 env, args,
134 [=](void *context) -> int {
135 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
136 return UpdateServiceKits::GetInstance().Cancel(upgradeInfo_, CAST_INT(UpdaterSaInterfaceCode::DOWNLOAD),
137 *businessError);
138 },
139 nullptr);
140 PARAM_CHECK(retValue != nullptr, sessionsMgr_->RemoveSession(sess->GetSessionId());
141 return nullptr, "Failed to start worker.");
142 return retValue;
143 }
144
145 template <typename T>
ParseUpgOptions(napi_env env,napi_callback_info info,VersionDigestInfo & versionDigestInfo,T & options)146 ClientStatus UpdateClient::ParseUpgOptions(napi_env env, napi_callback_info info, VersionDigestInfo &versionDigestInfo,
147 T &options)
148 {
149 size_t argc = MAX_ARGC;
150 napi_value args[MAX_ARGC] = { 0 };
151 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
152 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return ClientStatus::CLIENT_INVALID_PARAM, "Error get cb info");
153
154 ClientStatus ret = ClientHelper::GetVersionDigestInfoFromArg(env, args[0], versionDigestInfo);
155 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, return ClientStatus::CLIENT_INVALID_PARAM,
156 "Failed to get versionDigestInfo param");
157
158 ret = ClientHelper::GetOptionsFromArg(env, args[1], options);
159 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, return ClientStatus::CLIENT_INVALID_PARAM,
160 "Failed to get Options param");
161 return ClientStatus::CLIENT_SUCCESS;
162 }
163
ParseUpgOptions(napi_env env,napi_callback_info info,T & options)164 template <typename T> ClientStatus UpdateClient::ParseUpgOptions(napi_env env, napi_callback_info info, T &options)
165 {
166 size_t argc = MAX_ARGC;
167 napi_value args[MAX_ARGC] = { 0 };
168 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
169 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return ClientStatus::CLIENT_INVALID_PARAM, "Error get cb info");
170
171 ClientStatus ret = ClientHelper::GetOptionsFromArg(env, args[0], options);
172 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, return ClientStatus::CLIENT_INVALID_PARAM,
173 "Failed to get Options param");
174 return ClientStatus::CLIENT_SUCCESS;
175 }
176
Download(napi_env env,napi_callback_info info)177 napi_value UpdateClient::Download(napi_env env, napi_callback_info info)
178 {
179 size_t argc = MAX_ARGC;
180 napi_value args[MAX_ARGC] = { 0 };
181 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
182 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
183 ENGINE_LOGI("Download");
184
185 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, downloadOptions_);
186 std::vector<std::pair<std::string, std::string>> paramInfos;
187 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
188 paramInfos.push_back({ "downloadOptions", "DownloadOptions" });
189 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
190 return nullptr, "Failed to get Download param");
191
192 SessionParams sessionParams(SessionType::SESSION_DOWNLOAD, CALLBACK_POSITION_THREE, true);
193 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
194 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
195 return UpdateServiceKits::GetInstance().Download(upgradeInfo_, versionDigestInfo_, downloadOptions_,
196 *businessError);
197 });
198 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
199 return retValue;
200 }
201
PauseDownload(napi_env env,napi_callback_info info)202 napi_value UpdateClient::PauseDownload(napi_env env, napi_callback_info info)
203 {
204 size_t argc = MAX_ARGC;
205 napi_value args[MAX_ARGC] = { 0 };
206 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
207 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
208
209 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, pauseDownloadOptions_);
210 std::vector<std::pair<std::string, std::string>> paramInfos;
211 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
212 paramInfos.push_back({ "pauseDownloadOptions", "PauseDownloadOptions" });
213 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
214 return nullptr, "Failed to get pauseDownloadOptions param");
215
216 SessionParams sessionParams(SessionType::SESSION_PAUSE_DOWNLOAD, CALLBACK_POSITION_THREE, true);
217 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
218 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
219 return UpdateServiceKits::GetInstance().PauseDownload(upgradeInfo_, versionDigestInfo_, pauseDownloadOptions_,
220 *businessError);
221 });
222 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
223 return retValue;
224 }
225
ResumeDownload(napi_env env,napi_callback_info info)226 napi_value UpdateClient::ResumeDownload(napi_env env, napi_callback_info info)
227 {
228 size_t argc = MAX_ARGC;
229 napi_value args[MAX_ARGC] = { 0 };
230 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
231 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
232
233 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, resumeDownloadOptions_);
234 std::vector<std::pair<std::string, std::string>> paramInfos;
235 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
236 paramInfos.push_back({ "resumeDownloadOptions", "ResumeDownloadOptions" });
237 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
238 return nullptr, "Failed to get resumeDownloadOptions param");
239
240 SessionParams sessionParams(SessionType::SESSION_RESUME_DOWNLOAD, CALLBACK_POSITION_THREE, true);
241 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
242 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
243 return UpdateServiceKits::GetInstance().ResumeDownload(upgradeInfo_, versionDigestInfo_, resumeDownloadOptions_,
244 *businessError);
245 });
246 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
247 return retValue;
248 }
249
Upgrade(napi_env env,napi_callback_info info)250 napi_value UpdateClient::Upgrade(napi_env env, napi_callback_info info)
251 {
252 size_t argc = MAX_ARGC;
253 napi_value args[MAX_ARGC] = { 0 };
254 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
255 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
256
257 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, upgradeOptions_);
258 std::vector<std::pair<std::string, std::string>> paramInfos;
259 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
260 paramInfos.push_back({ "upgradeOptions", "UpgradeOptions" });
261 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
262 return nullptr, "Failed to get upgradeOptions param");
263
264 SessionParams sessionParams(SessionType::SESSION_UPGRADE, CALLBACK_POSITION_THREE, true);
265 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
266 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
267 return UpdateServiceKits::GetInstance().Upgrade(upgradeInfo_, versionDigestInfo_, upgradeOptions_,
268 *businessError);
269 });
270 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
271 return retValue;
272 }
273
ClearError(napi_env env,napi_callback_info info)274 napi_value UpdateClient::ClearError(napi_env env, napi_callback_info info)
275 {
276 size_t argc = MAX_ARGC;
277 napi_value args[MAX_ARGC] = { 0 };
278 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
279 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
280
281 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, clearOptions_);
282 std::vector<std::pair<std::string, std::string>> paramInfos;
283 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
284 paramInfos.push_back({ "clearOptions", "ClearOptions" });
285 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
286 return nullptr, "Failed to get clearOptions param");
287
288 SessionParams sessionParams(SessionType::SESSION_CLEAR_ERROR, CALLBACK_POSITION_THREE, true);
289 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
290 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
291 return UpdateServiceKits::GetInstance().ClearError(upgradeInfo_, versionDigestInfo_, clearOptions_,
292 *businessError);
293 });
294 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
295 return retValue;
296 }
297
TerminateUpgrade(napi_env env,napi_callback_info info)298 napi_value UpdateClient::TerminateUpgrade(napi_env env, napi_callback_info info)
299 {
300 size_t argc = MAX_ARGC;
301 napi_value args[MAX_ARGC] = { 0 };
302 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
303 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
304
305 SessionParams sessionParams(SessionType::SESSION_TERMINATE_UPGRADE, CALLBACK_POSITION_ONE, true);
306 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
307 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
308 return UpdateServiceKits::GetInstance().TerminateUpgrade(upgradeInfo_, *businessError);
309 });
310 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
311 return retValue;
312 }
313
SetUpgradePolicy(napi_env env,napi_callback_info info)314 napi_value UpdateClient::SetUpgradePolicy(napi_env env, napi_callback_info info)
315 {
316 size_t argc = MAX_ARGC;
317 napi_value args[MAX_ARGC] = { 0 };
318 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
319 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
320
321 ClientStatus ret = ClientHelper::GetUpgradePolicyFromArg(env, args[0], upgradePolicy_);
322 std::vector<std::pair<std::string, std::string>> paramInfos;
323 paramInfos.push_back({ "upgradePolicy", "UpgradePolicy" });
324 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
325 return nullptr, "Failed to get upgradePolicy param");
326
327 SessionParams sessionParams(SessionType::SESSION_SET_POLICY, CALLBACK_POSITION_TWO, true);
328 napi_value retValue = StartSession(env, info, sessionParams, [&](void *context) -> int {
329 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
330 return UpdateServiceKits::GetInstance().SetUpgradePolicy(upgradeInfo_, upgradePolicy_, *businessError);
331 });
332 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to SetUpgradePolicy.");
333 return retValue;
334 }
335
GetUpgradePolicy(napi_env env,napi_callback_info info)336 napi_value UpdateClient::GetUpgradePolicy(napi_env env, napi_callback_info info)
337 {
338 SessionParams sessionParams(SessionType::SESSION_GET_POLICY, CALLBACK_POSITION_ONE, true);
339 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
340 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
341 return UpdateServiceKits::GetInstance().GetUpgradePolicy(upgradeInfo_, upgradePolicy_, *businessError);
342 });
343 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to UpgradeVersion.");
344 return retValue;
345 }
346
GetNewVersionInfo(napi_env env,napi_callback_info info)347 napi_value UpdateClient::GetNewVersionInfo(napi_env env, napi_callback_info info)
348 {
349 SessionParams sessionParams(SessionType::SESSION_GET_NEW_VERSION, CALLBACK_POSITION_ONE, true);
350 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
351 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
352 return UpdateServiceKits::GetInstance().GetNewVersionInfo(upgradeInfo_, newVersionInfo_, *businessError);
353 });
354 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to GetNewVersionInfo.");
355 return retValue;
356 }
357
GetNewVersionDescription(napi_env env,napi_callback_info info)358 napi_value UpdateClient::GetNewVersionDescription(napi_env env, napi_callback_info info)
359 {
360 size_t argc = MAX_ARGC;
361 napi_value args[MAX_ARGC] = { 0 };
362 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
363 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
364 ENGINE_LOGI("GetNewVersionDescription");
365
366 ClientStatus ret = ParseUpgOptions(env, info, versionDigestInfo_, descriptionOptions_);
367 std::vector<std::pair<std::string, std::string>> paramInfos;
368 paramInfos.push_back({ "versionDigestInfo", "VersionDigestInfo" });
369 paramInfos.push_back({ "descriptionOptions", "DescriptionOptions" });
370 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
371 return nullptr, "Failed to get descriptionOptions param");
372
373 SessionParams sessionParams(SessionType::SESSION_GET_NEW_VERSION_DESCRIPTION, CALLBACK_POSITION_THREE, true);
374 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
375 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
376 return UpdateServiceKits::GetInstance().GetNewVersionDescription(upgradeInfo_, versionDigestInfo_,
377 descriptionOptions_, newVersionDescriptionInfo_, *businessError);
378 });
379 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
380 return retValue;
381 }
382
GetCurrentVersionInfo(napi_env env,napi_callback_info info)383 napi_value UpdateClient::GetCurrentVersionInfo(napi_env env, napi_callback_info info)
384 {
385 SessionParams sessionParams(SessionType::SESSION_GET_CUR_VERSION, CALLBACK_POSITION_ONE, true);
386 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
387 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
388 return UpdateServiceKits::GetInstance().GetCurrentVersionInfo(upgradeInfo_, currentVersionInfo_,
389 *businessError);
390 });
391 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to GetCurrentVersionInfo.");
392 return retValue;
393 }
394
GetCurrentVersionDescription(napi_env env,napi_callback_info info)395 napi_value UpdateClient::GetCurrentVersionDescription(napi_env env, napi_callback_info info)
396 {
397 size_t argc = MAX_ARGC;
398 napi_value args[MAX_ARGC] = { 0 };
399 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
400 PARAM_CHECK_NAPI_CALL(env, status == napi_ok, return nullptr, "Error get cb info");
401 ENGINE_LOGI("GetCurrentVersionDescription");
402
403 ClientStatus ret = ParseUpgOptions(env, info, descriptionOptions_);
404 std::vector<std::pair<std::string, std::string>> paramInfos;
405 paramInfos.push_back({ "descriptionOptions", "DescriptionOptions" });
406 PARAM_CHECK(ret == ClientStatus::CLIENT_SUCCESS, NapiCommonUtils::NapiThrowParamError(env, paramInfos);
407 return nullptr, "Failed to get descriptionOptions param");
408
409 SessionParams sessionParams(SessionType::SESSION_GET_CUR_VERSION_DESCRIPTION, CALLBACK_POSITION_TWO, true);
410 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
411 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
412 return UpdateServiceKits::GetInstance().GetCurrentVersionDescription(upgradeInfo_, descriptionOptions_,
413 currentVersionDescriptionInfo_, *businessError);
414 });
415 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to start worker.");
416 return retValue;
417 }
418
GetTaskInfo(napi_env env,napi_callback_info info)419 napi_value UpdateClient::GetTaskInfo(napi_env env, napi_callback_info info)
420 {
421 SessionParams sessionParams(SessionType::SESSION_GET_TASK_INFO, CALLBACK_POSITION_ONE, true);
422 napi_value retValue = StartSession(env, info, sessionParams, [=](void *context) -> int {
423 BusinessError *businessError = reinterpret_cast<BusinessError *>(context);
424 return UpdateServiceKits::GetInstance().GetTaskInfo(upgradeInfo_, taskInfo_, *businessError);
425 });
426 PARAM_CHECK(retValue != nullptr, return nullptr, "Failed to GetTaskInfo.");
427 return retValue;
428 }
429
GetUpdateResult(uint32_t type,UpdateResult & result)430 void UpdateClient::GetUpdateResult(uint32_t type, UpdateResult &result)
431 {
432 ENGINE_LOGI("GetUpdateResult type %{public}d", type);
433 result.type = type;
434 switch (type) {
435 case SessionType::SESSION_CHECK_VERSION:
436 result.result.checkResult = &checkResult_;
437 result.buildJSObject = ClientHelper::BuildCheckResult;
438 break;
439 case SessionType::SESSION_GET_NEW_VERSION:
440 result.result.newVersionInfo = &newVersionInfo_;
441 result.buildJSObject = ClientHelper::BuildNewVersionInfo;
442 break;
443 case SessionType::SESSION_GET_NEW_VERSION_DESCRIPTION:
444 result.result.versionDescriptionInfo = &newVersionDescriptionInfo_;
445 result.buildJSObject = ClientHelper::BuildVersionDescriptionInfo;
446 break;
447 case SessionType::SESSION_GET_TASK_INFO:
448 result.result.taskInfo = &taskInfo_;
449 result.buildJSObject = ClientHelper::BuildTaskInfo;
450 break;
451 case SessionType::SESSION_GET_CUR_VERSION:
452 result.result.currentVersionInfo = ¤tVersionInfo_;
453 result.buildJSObject = ClientHelper::BuildCurrentVersionInfo;
454 break;
455 case SessionType::SESSION_GET_CUR_VERSION_DESCRIPTION:
456 result.result.versionDescriptionInfo = ¤tVersionDescriptionInfo_;
457 result.buildJSObject = ClientHelper::BuildVersionDescriptionInfo;
458 break;
459 case SessionType::SESSION_GET_POLICY:
460 result.result.upgradePolicy = &upgradePolicy_;
461 result.buildJSObject = ClientHelper::BuildUpgradePolicy;
462 break;
463 default:
464 result.buildJSObject = ClientHelper::BuildUndefinedStatus;
465 break;
466 }
467 }
468 } // namespace OHOS::UpdateEngine