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