1 /*
2 * Copyright (c) 2023-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 #include "system_manager_addon.h"
16
17 #include "securec.h"
18
19 #include "edm_constants.h"
20 #include "edm_log.h"
21 #include "napi_edm_adapter.h"
22
23 using namespace OHOS::EDM;
24
Init(napi_env env,napi_value exports)25 napi_value SystemManagerAddon::Init(napi_env env, napi_value exports)
26 {
27 napi_value nPolicyType = nullptr;
28 NAPI_CALL(env, napi_create_object(env, &nPolicyType));
29 CreatePolicyTypeObject(env, nPolicyType);
30
31 napi_value nPackageType = nullptr;
32 NAPI_CALL(env, napi_create_object(env, &nPackageType));
33 CreatePackageTypeObject(env, nPackageType);
34
35 napi_value nUpgradeStatus = nullptr;
36 NAPI_CALL(env, napi_create_object(env, &nUpgradeStatus));
37 CreateUpgradeStatusObject(env, nUpgradeStatus);
38
39 napi_property_descriptor property[] = {
40 DECLARE_NAPI_FUNCTION("setNTPServer", SetNTPServer),
41 DECLARE_NAPI_FUNCTION("getNTPServer", GetNTPServer),
42 DECLARE_NAPI_FUNCTION("setOtaUpdatePolicy", SetOTAUpdatePolicy),
43 DECLARE_NAPI_FUNCTION("getOtaUpdatePolicy", GetOTAUpdatePolicy),
44 DECLARE_NAPI_FUNCTION("notifyUpdatePackages", NotifyUpdatePackages),
45 DECLARE_NAPI_FUNCTION("getUpdateResult", GetUpgradeResult),
46 DECLARE_NAPI_FUNCTION("getUpdateAuthData", GetUpdateAuthData),
47
48 DECLARE_NAPI_PROPERTY("PolicyType", nPolicyType),
49 DECLARE_NAPI_PROPERTY("PackageType", nPackageType),
50 DECLARE_NAPI_PROPERTY("UpdateStatus", nUpgradeStatus),
51 };
52 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
53 return exports;
54 }
55
CreatePolicyTypeObject(napi_env env,napi_value value)56 void SystemManagerAddon::CreatePolicyTypeObject(napi_env env, napi_value value)
57 {
58 napi_value nDefault;
59 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(UpdatePolicyType::DEFAULT), &nDefault));
60 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DEFAULT", nDefault));
61 napi_value nProhibit;
62 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(UpdatePolicyType::PROHIBIT), &nProhibit));
63 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PROHIBIT", nProhibit));
64 napi_value nUpdateToSpecificVersion;
65 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
66 static_cast<int32_t>(UpdatePolicyType::UPDATE_TO_SPECIFIC_VERSION), &nUpdateToSpecificVersion));
67 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UPDATE_TO_SPECIFIC_VERSION",
68 nUpdateToSpecificVersion));
69 napi_value nWindows;
70 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(UpdatePolicyType::WINDOWS), &nWindows));
71 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WINDOWS", nWindows));
72 napi_value nPostpone;
73 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(UpdatePolicyType::POSTPONE), &nPostpone));
74 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "POSTPONE", nPostpone));
75 }
76
CreatePackageTypeObject(napi_env env,napi_value value)77 void SystemManagerAddon::CreatePackageTypeObject(napi_env env, napi_value value)
78 {
79 napi_value nFirmware;
80 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(PackageType::FIRMWARE), &nFirmware));
81 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "FIRMWARE", nFirmware));
82 }
83
CreateUpgradeStatusObject(napi_env env,napi_value value)84 void SystemManagerAddon::CreateUpgradeStatusObject(napi_env env, napi_value value)
85 {
86 napi_value nNoUpgradePackage;
87 NAPI_CALL_RETURN_VOID(env,
88 napi_create_int32(env, static_cast<int32_t>(UpgradeStatus::NO_UPGRADE_PACKAGE), &nNoUpgradePackage));
89 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "NO_UPDATE_PACKAGE", nNoUpgradePackage));
90
91 napi_value nUpgradeWaiting;
92 NAPI_CALL_RETURN_VOID(env,
93 napi_create_int32(env, static_cast<int32_t>(UpgradeStatus::UPGRADE_WAITING), &nUpgradeWaiting));
94 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UPDATE_WAITING", nUpgradeWaiting));
95
96 napi_value nUpgrading;
97 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(UpgradeStatus::UPGRADING), &nUpgrading));
98 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UPDATING", nUpgrading));
99
100 napi_value nUpgradeFailure;
101 NAPI_CALL_RETURN_VOID(env,
102 napi_create_int32(env, static_cast<int32_t>(UpgradeStatus::UPGRADE_FAILURE), &nUpgradeFailure));
103 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UPDATE_FAILURE", nUpgradeFailure));
104
105 napi_value nUpgradeSuccess;
106 NAPI_CALL_RETURN_VOID(env,
107 napi_create_int32(env, static_cast<int32_t>(UpgradeStatus::UPGRADE_SUCCESS), &nUpgradeSuccess));
108 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UPDATE_SUCCESS", nUpgradeSuccess));
109 }
110
SetNTPServer(napi_env env,napi_callback_info info)111 napi_value SystemManagerAddon::SetNTPServer(napi_env env, napi_callback_info info)
112 {
113 EDMLOGI("SetNTPServer Addon called");
114 AddonMethodSign addonMethodSign;
115 addonMethodSign.name = "SetNTPServer";
116 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING};
117 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
118 AdapterAddonData adapterAddonData{};
119 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
120 if (result == nullptr) {
121 return nullptr;
122 }
123 int32_t ret = SystemManagerProxy::GetSystemManagerProxy()->SetNTPServer(adapterAddonData.data);
124 if (FAILED(ret)) {
125 napi_throw(env, CreateError(env, ret));
126 EDMLOGE("SetNTPServer failed!");
127 }
128 return nullptr;
129 }
130
GetNTPServer(napi_env env,napi_callback_info info)131 napi_value SystemManagerAddon::GetNTPServer(napi_env env, napi_callback_info info)
132 {
133 EDMLOGI("GetNTPServer Addon called");
134 AddonMethodSign addonMethodSign;
135 addonMethodSign.name = "GetNTPServer";
136 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
137 addonMethodSign.methodAttribute = MethodAttribute::GET;
138 AdapterAddonData adapterAddonData{};
139 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
140 if (result == nullptr) {
141 return nullptr;
142 }
143 std::string ntpParm;
144 int32_t ret = SystemManagerProxy::GetSystemManagerProxy()->GetNTPServer(adapterAddonData.data, ntpParm);
145 if (FAILED(ret)) {
146 napi_throw(env, CreateError(env, ret));
147 EDMLOGE("GetNTPServer failed!");
148 return nullptr;
149 }
150 napi_value ntpServerString = nullptr;
151 NAPI_CALL(env, napi_create_string_utf8(env, ntpParm.c_str(), ntpParm.size(), &ntpServerString));
152 return ntpServerString;
153 }
154
SetOTAUpdatePolicy(napi_env env,napi_callback_info info)155 napi_value SystemManagerAddon::SetOTAUpdatePolicy(napi_env env, napi_callback_info info)
156 {
157 auto convertupdatePolicy2Data = [](napi_env env, napi_value argv, MessageParcel &data,
158 const AddonMethodSign &methodSign) {
159 UpdatePolicy updatePolicy;
160 std::string errorMsg;
161 if (!JsObjToUpdatePolicy(env, argv, updatePolicy, errorMsg)) {
162 EDMLOGE("%{public}s", errorMsg.c_str());
163 return false;
164 }
165 UpdatePolicyUtils::WriteUpdatePolicy(data, updatePolicy);
166 return true;
167 };
168 AddonMethodSign addonMethodSign;
169 addonMethodSign.name = "SetOTAUpdatePolicy";
170 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
171 addonMethodSign.argsConvert = {nullptr, convertupdatePolicy2Data};
172 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
173 AdapterAddonData adapterAddonData{};
174 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
175 if (result == nullptr) {
176 return nullptr;
177 }
178 std::string message;
179 int32_t ret = SystemManagerProxy::GetSystemManagerProxy()->SetOTAUpdatePolicy(adapterAddonData.data, message);
180 if (ret == EdmReturnErrCode::PARAM_ERROR) {
181 napi_throw(env, CreateError(env, ret, message));
182 } else if (FAILED(ret)) {
183 napi_throw(env, CreateError(env, ret));
184 }
185 return nullptr;
186 }
187
GetOTAUpdatePolicy(napi_env env,napi_callback_info info)188 napi_value SystemManagerAddon::GetOTAUpdatePolicy(napi_env env, napi_callback_info info)
189 {
190 AddonMethodSign addonMethodSign;
191 addonMethodSign.name = "GetOTAUpdatePolicy";
192 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
193 addonMethodSign.methodAttribute = MethodAttribute::GET;
194 AdapterAddonData adapterAddonData{};
195 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
196 if (result == nullptr) {
197 return nullptr;
198 }
199 UpdatePolicy updatePolicy;
200 int32_t ret = SystemManagerProxy::GetSystemManagerProxy()->GetOTAUpdatePolicy(adapterAddonData.data, updatePolicy);
201 if (FAILED(ret)) {
202 napi_throw(env, CreateError(env, ret));
203 return nullptr;
204 }
205 return ConvertUpdatePolicyToJs(env, updatePolicy);
206 }
207
NotifyUpdatePackages(napi_env env,napi_callback_info info)208 napi_value SystemManagerAddon::NotifyUpdatePackages(napi_env env, napi_callback_info info)
209 {
210 EDMLOGI("NAPI_NotifyUpdatePackages called");
211 size_t argc = ARGS_SIZE_TWO;
212 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
213 napi_value thisArg = nullptr;
214 void *data = nullptr;
215 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
216 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
217 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
218 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object), "parameter policy error");
219 auto asyncCallbackInfo = new (std::nothrow) AsyncNotifyUpdatePackagesCallbackInfo();
220 if (asyncCallbackInfo == nullptr) {
221 return nullptr;
222 }
223 std::unique_ptr<AsyncNotifyUpdatePackagesCallbackInfo> callbackPtr{asyncCallbackInfo};
224 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
225 "element name param error");
226 EDMLOGD(
227 "IsAdminEnabled::asyncCallbackInfo->elementName.bundlename %{public}s, "
228 "asyncCallbackInfo->abilityname:%{public}s",
229 asyncCallbackInfo->elementName.GetBundleName().c_str(),
230 asyncCallbackInfo->elementName.GetAbilityName().c_str());
231 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToUpgradePackageInfo(env, argv[ARR_INDEX_ONE],
232 asyncCallbackInfo->packageInfo), "parameter packageInfo parse error");
233
234 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "NotifyUpdatePackages",
235 NativeNotifyUpdatePackages, NativeVoidCallbackComplete);
236 callbackPtr.release();
237 return asyncWorkReturn;
238 }
239
NativeNotifyUpdatePackages(napi_env env,void * data)240 void SystemManagerAddon::NativeNotifyUpdatePackages(napi_env env, void *data)
241 {
242 EDMLOGI("NAPI_NativeNotifyUpdatePackages called");
243 if (data == nullptr) {
244 EDMLOGE("data is nullptr");
245 return;
246 }
247 auto *asyncCallbackInfo = static_cast<AsyncNotifyUpdatePackagesCallbackInfo *>(data);
248 auto proxy = SystemManagerProxy::GetSystemManagerProxy();
249 if (proxy == nullptr) {
250 UpdatePolicyUtils::ClosePackagesFileHandle(asyncCallbackInfo->packageInfo.packages);
251 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
252 return;
253 }
254 asyncCallbackInfo->ret = proxy->NotifyUpdatePackages(asyncCallbackInfo->elementName, asyncCallbackInfo->packageInfo,
255 asyncCallbackInfo->innerCodeMsg);
256 }
257
GetUpgradeResult(napi_env env,napi_callback_info info)258 napi_value SystemManagerAddon::GetUpgradeResult(napi_env env, napi_callback_info info)
259 {
260 EDMLOGI("NAPI_GetOTAUpdatePolicy called");
261 size_t argc = ARGS_SIZE_TWO;
262 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
263 napi_value thisArg = nullptr;
264 void *data = nullptr;
265 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
266 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
267 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
268 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter version error");
269
270 auto asyncCallbackInfo = new (std::nothrow) AsyncGetUpgradeResultCallbackInfo();
271 if (asyncCallbackInfo == nullptr) {
272 return nullptr;
273 }
274 std::unique_ptr<AsyncGetUpgradeResultCallbackInfo> callbackPtr{asyncCallbackInfo};
275 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
276 "element name param error");
277 EDMLOGD(
278 "IsAdminEnabled::asyncCallbackInfo->elementName.bundlename %{public}s, "
279 "asyncCallbackInfo->abilityname:%{public}s",
280 asyncCallbackInfo->elementName.GetBundleName().c_str(),
281 asyncCallbackInfo->elementName.GetAbilityName().c_str());
282 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->version, argv[ARR_INDEX_ONE]),
283 "version param error");
284
285 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetUpgradeResult", NativeGetUpgradeResult,
286 NativeUpgradeResultComplete);
287 callbackPtr.release();
288 return asyncWorkReturn;
289 }
290
GetUpdateAuthData(napi_env env,napi_callback_info info)291 napi_value SystemManagerAddon::GetUpdateAuthData(napi_env env, napi_callback_info info)
292 {
293 EDMLOGI("NAPI_GetUpdateAuthData called");
294 AddonMethodSign addonMethodSign;
295 addonMethodSign.name = "GetUpdateAuthData";
296 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
297 addonMethodSign.methodAttribute = MethodAttribute::GET;
298 return AddonMethodAdapter(env, info, addonMethodSign, NativeGetUpdateAuthData, NativeStringCallbackComplete);
299 }
300
NativeGetUpgradeResult(napi_env env,void * data)301 void SystemManagerAddon::NativeGetUpgradeResult(napi_env env, void *data)
302 {
303 EDMLOGI("NAPI_NativeGetUpgradeResult called");
304 if (data == nullptr) {
305 EDMLOGE("data is nullptr");
306 return;
307 }
308 AsyncGetUpgradeResultCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetUpgradeResultCallbackInfo *>(data);
309 auto proxy = SystemManagerProxy::GetSystemManagerProxy();
310 if (proxy == nullptr) {
311 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
312 return;
313 }
314 asyncCallbackInfo->ret = proxy->GetUpgradeResult(asyncCallbackInfo->elementName, asyncCallbackInfo->version,
315 asyncCallbackInfo->upgradeResult);
316 }
317
NativeGetUpdateAuthData(napi_env env,void * data)318 void SystemManagerAddon::NativeGetUpdateAuthData(napi_env env, void *data)
319 {
320 EDMLOGI("NAPI_NativeGetUpdateAuthData called");
321 if (data == nullptr) {
322 EDMLOGE("data is nullptr");
323 return;
324 }
325 auto *asyncCallbakInfo = static_cast<AdapterAddonData *>(data);
326 asyncCallbakInfo->ret = SystemManagerProxy::GetSystemManagerProxy()->GetUpdateAuthData(asyncCallbakInfo->data,
327 asyncCallbakInfo->stringRet);
328 }
329
NativeUpgradeResultComplete(napi_env env,napi_status status,void * data)330 void SystemManagerAddon::NativeUpgradeResultComplete(napi_env env, napi_status status, void *data)
331 {
332 if (data == nullptr) {
333 EDMLOGE("data is nullptr");
334 return;
335 }
336 auto *asyncCallbackInfo = static_cast<AsyncGetUpgradeResultCallbackInfo *>(data);
337 if (asyncCallbackInfo->deferred != nullptr) {
338 EDMLOGD("asyncCallbackInfo->deferred != nullptr");
339 if (asyncCallbackInfo->ret == ERR_OK) {
340 napi_value result = ConvertUpdateResultToJs(env, asyncCallbackInfo->upgradeResult);
341 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
342 } else {
343 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
344 }
345 }
346 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
347 delete asyncCallbackInfo;
348 }
349
JsObjToUpdatePolicy(napi_env env,napi_value object,UpdatePolicy & updatePolicy,std::string & errorMsg)350 bool SystemManagerAddon::JsObjToUpdatePolicy(napi_env env, napi_value object, UpdatePolicy &updatePolicy,
351 std::string &errorMsg)
352 {
353 int32_t policyType = -1;
354 if (!JsObjectToInt(env, object, "policyType", true, policyType) ||
355 !UpdatePolicyUtils::ProcessUpdatePolicyType(policyType, updatePolicy.type)) {
356 errorMsg = "the property 'policyType' in type 'OtaUpdatePolicy' is necessary";
357 return false;
358 }
359
360 if (!JsObjectToString(env, object, "version", true, updatePolicy.version)) {
361 errorMsg = "the property 'version' in type 'OtaUpdatePolicy' is necessary";
362 return false;
363 }
364
365 if (!JsObjectToLong(env, object, "latestUpdateTime", false, updatePolicy.installTime.latestUpdateTime)) {
366 errorMsg = "the property 'latestUpdateTime' in type 'OtaUpdatePolicy' is check failed";
367 return false;
368 }
369
370 if (!JsObjectToLong(env, object, "installStartTime", updatePolicy.type == UpdatePolicyType::WINDOWS,
371 updatePolicy.installTime.installWindowStart)) {
372 errorMsg = "the property 'installStartTime' in type 'OtaUpdatePolicy' is check failed";
373 return false;
374 }
375
376 if (!JsObjectToLong(env, object, "installEndTime", updatePolicy.type == UpdatePolicyType::WINDOWS,
377 updatePolicy.installTime.installWindowEnd)) {
378 errorMsg = "the property 'installEndTime' in type 'OtaUpdatePolicy' is check failed";
379 return false;
380 }
381
382 if (!JsObjectToLong(env, object, "delayUpdateTime", updatePolicy.type == UpdatePolicyType::POSTPONE,
383 updatePolicy.installTime.delayUpdateTime)) {
384 errorMsg = "the property 'delayUpdateTime' in type 'OtaUpdatePolicy' is check failed";
385 return false;
386 }
387 return true;
388 }
389
ConvertUpdatePolicyToJs(napi_env env,const UpdatePolicy & updatePolicy)390 napi_value SystemManagerAddon::ConvertUpdatePolicyToJs(napi_env env, const UpdatePolicy &updatePolicy)
391 {
392 napi_value otaUpdatePolicy = nullptr;
393 NAPI_CALL(env, napi_create_object(env, &otaUpdatePolicy));
394
395 napi_value policyType = nullptr;
396 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(updatePolicy.type), &policyType));
397 NAPI_CALL(env, napi_set_named_property(env, otaUpdatePolicy, "policyType", policyType));
398
399 napi_value version = nullptr;
400 NAPI_CALL(env, napi_create_string_utf8(env, updatePolicy.version.c_str(), updatePolicy.version.length(), &version));
401 NAPI_CALL(env, napi_set_named_property(env, otaUpdatePolicy, "version", version));
402
403 napi_value latestUpdateTime = nullptr;
404 NAPI_CALL(env, napi_create_int64(env, updatePolicy.installTime.latestUpdateTime, &latestUpdateTime));
405 NAPI_CALL(env, napi_set_named_property(env, otaUpdatePolicy, "latestUpdateTime", latestUpdateTime));
406
407 napi_value delayUpdateTime = nullptr;
408 NAPI_CALL(env, napi_create_int64(env, updatePolicy.installTime.delayUpdateTime, &delayUpdateTime));
409 NAPI_CALL(env, napi_set_named_property(env, otaUpdatePolicy, "delayUpdateTime", delayUpdateTime));
410
411 napi_value installStartTime = nullptr;
412 NAPI_CALL(env, napi_create_int64(env, updatePolicy.installTime.installWindowStart, &installStartTime));
413 NAPI_CALL(env, napi_set_named_property(env, otaUpdatePolicy, "installStartTime", installStartTime));
414
415 napi_value installEndTime = nullptr;
416 NAPI_CALL(env, napi_create_int64(env, updatePolicy.installTime.installWindowEnd, &installEndTime));
417 NAPI_CALL(env, napi_set_named_property(env, otaUpdatePolicy, "installEndTime", installEndTime));
418 return otaUpdatePolicy;
419 }
420
JsObjToUpgradePackageInfo(napi_env env,napi_value object,UpgradePackageInfo & packageInfo)421 bool SystemManagerAddon::JsObjToUpgradePackageInfo(napi_env env, napi_value object, UpgradePackageInfo &packageInfo)
422 {
423 if (!JsObjectToString(env, object, "version", true, packageInfo.version)) {
424 EDMLOGE("JsObjToUpgradePackageInfo version trans failed!");
425 return false;
426 }
427
428 napi_value nPackages;
429 if (!GetJsProperty(env, object, "packages", nPackages) || !ParsePackages(env, nPackages, packageInfo.packages)) {
430 UpdatePolicyUtils::ClosePackagesFileHandle(packageInfo.packages);
431 return false;
432 }
433
434 napi_value nDescription;
435 if (GetJsProperty(env, object, "description", nDescription) &&
436 !ParseDescription(env, nDescription, packageInfo.description)) {
437 UpdatePolicyUtils::ClosePackagesFileHandle(packageInfo.packages);
438 return false;
439 }
440 std::tuple<int, bool> charArrayProp = {EdmConstants::AUTH_INFO_MAX_SIZE, false};
441 std::vector<char> ret;
442 if (!JsObjectToCharArray(env, object, "authInfo", charArrayProp, ret)) {
443 EDMLOGE("JsObjToUpgradePackageInfo authInfo trans failed!");
444 return false;
445 }
446 errno_t err = memcpy_s(packageInfo.authInfo, sizeof(packageInfo.authInfo), ret.data(), ret.size());
447 memset_s(ret.data(), ret.size(), 0, ret.size());
448 if (err != EOK) {
449 return false;
450 }
451 packageInfo.authInfoSize = ret.size() - 1;
452 return true;
453 }
454
ParsePackages(napi_env env,napi_value object,std::vector<Package> & packages)455 bool SystemManagerAddon::ParsePackages(napi_env env, napi_value object, std::vector<Package> &packages)
456 {
457 bool isArray = false;
458 if (napi_is_array(env, object, &isArray) != napi_ok || !isArray) {
459 return false;
460 }
461 uint32_t len = 0;
462 if (napi_get_array_length(env, object, &len) != napi_ok) {
463 return false;
464 }
465 for (uint32_t i = 0; i < len; i++) {
466 napi_value nPackage;
467 if (napi_get_element(env, object, i, &nPackage) != napi_ok) {
468 return false;
469 }
470 Package package;
471 if (!ParsePackage(env, nPackage, package)) {
472 return false;
473 }
474 packages.push_back(package);
475 }
476 return true;
477 }
478
ParsePackage(napi_env env,napi_value object,Package & package)479 bool SystemManagerAddon::ParsePackage(napi_env env, napi_value object, Package &package)
480 {
481 int32_t type = static_cast<int32_t>(PackageType::UNKNOWN);
482 if (!JsObjectToInt(env, object, "type", true, type)) {
483 return false;
484 }
485 if (type != static_cast<int32_t>(PackageType::FIRMWARE)) {
486 return false;
487 }
488 package.type = static_cast<PackageType>(type);
489 return JsObjectToString(env, object, "path", true, package.path) &&
490 JsObjectToInt(env, object, "fd", false, package.fd);
491 }
492
ParseDescription(napi_env env,napi_value object,PackageDescription & description)493 bool SystemManagerAddon::ParseDescription(napi_env env, napi_value object, PackageDescription &description)
494 {
495 napi_value nNotify;
496 if (GetJsProperty(env, object, "notify", nNotify)) {
497 if (!JsObjectToString(env, nNotify, "installTips", false, description.notify.installTips) ||
498 !JsObjectToString(env, nNotify, "installTipsDetails", false, description.notify.installTipsDetail)) {
499 return false;
500 }
501 }
502 return true;
503 }
504
ConvertUpdateResultToJs(napi_env env,const UpgradeResult & updateResult)505 napi_value SystemManagerAddon::ConvertUpdateResultToJs(napi_env env, const UpgradeResult &updateResult)
506 {
507 napi_value nUpgradeResult = nullptr;
508 NAPI_CALL(env, napi_create_object(env, &nUpgradeResult));
509
510 napi_value version = nullptr;
511 NAPI_CALL(env, napi_create_string_utf8(env, updateResult.version.c_str(), updateResult.version.length(), &version));
512 NAPI_CALL(env, napi_set_named_property(env, nUpgradeResult, "version", version));
513
514 napi_value status = nullptr;
515 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(updateResult.status), &status));
516 NAPI_CALL(env, napi_set_named_property(env, nUpgradeResult, "status", status));
517
518 napi_value nErrorInfo = nullptr;
519 NAPI_CALL(env, napi_create_object(env, &nErrorInfo));
520
521 napi_value errorCode = nullptr;
522 NAPI_CALL(env, napi_create_int32(env, updateResult.errorCode, &errorCode));
523 NAPI_CALL(env, napi_set_named_property(env, nErrorInfo, "code", errorCode));
524
525 napi_value errorMessage = nullptr;
526 NAPI_CALL(env, napi_create_string_utf8(env, updateResult.errorMessage.c_str(), updateResult.errorMessage.length(),
527 &errorMessage));
528 NAPI_CALL(env, napi_set_named_property(env, nErrorInfo, "message", errorMessage));
529
530 NAPI_CALL(env, napi_set_named_property(env, nUpgradeResult, "errorInfo", nErrorInfo));
531 return nUpgradeResult;
532 }
533
534 static napi_module g_systemManagerModule = {
535 .nm_version = 1,
536 .nm_flags = 0,
537 .nm_filename = nullptr,
538 .nm_register_func = SystemManagerAddon::Init,
539 .nm_modname = "enterprise.systemManager",
540 .nm_priv = ((void *)0),
541 .reserved = { 0 },
542 };
543
SystemManagerRegister()544 extern "C" __attribute__((constructor)) void SystemManagerRegister()
545 {
546 napi_module_register(&g_systemManagerModule);
547 }