1 /*
2 * Copyright (c) 2023 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 "device_settings_addon.h"
16
17 #include "edm_log.h"
18
19 using namespace OHOS::EDM;
20
CreatePowerSceneObject(napi_env env,napi_value value)21 void DeviceSettingsAddon::CreatePowerSceneObject(napi_env env, napi_value value)
22 {
23 napi_value nTimeOut;
24 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(PowerScene::TIME_OUT), &nTimeOut));
25 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TIME_OUT", nTimeOut));
26 }
27
CreatePowerPolicyActionObject(napi_env env,napi_value value)28 void DeviceSettingsAddon::CreatePowerPolicyActionObject(napi_env env, napi_value value)
29 {
30 napi_value nActionNone;
31 NAPI_CALL_RETURN_VOID(env,
32 napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::NONE), &nActionNone));
33 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "NONE", nActionNone));
34 napi_value nActionAutoSuspend;
35 NAPI_CALL_RETURN_VOID(env,
36 napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::AUTO_SUSPEND), &nActionAutoSuspend));
37 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "AUTO_SUSPEND", nActionAutoSuspend));
38 napi_value nActionForceSuspend;
39 NAPI_CALL_RETURN_VOID(env,
40 napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::FORCE_SUSPEND), &nActionForceSuspend));
41 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "FORCE_SUSPEND", nActionForceSuspend));
42 napi_value nActionHibernate;
43 NAPI_CALL_RETURN_VOID(env,
44 napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::HIBERNATE), &nActionHibernate));
45 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "HIBERNATE", nActionHibernate));
46 napi_value nActionShutDown;
47 NAPI_CALL_RETURN_VOID(env,
48 napi_create_uint32(env, static_cast<uint32_t>(PowerPolicyAction::SHUTDOWN), &nActionShutDown));
49 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "SHUTDOWN", nActionShutDown));
50 }
51
Init(napi_env env,napi_value exports)52 napi_value DeviceSettingsAddon::Init(napi_env env, napi_value exports)
53 {
54 napi_value nTimeOut = nullptr;
55 NAPI_CALL(env, napi_create_object(env, &nTimeOut));
56 CreatePowerSceneObject(env, nTimeOut);
57 napi_value nPolicyAction = nullptr;
58 NAPI_CALL(env, napi_create_object(env, &nPolicyAction));
59 CreatePowerPolicyActionObject(env, nPolicyAction);
60
61 napi_property_descriptor property[] = {
62 DECLARE_NAPI_FUNCTION("setScreenOffTime", SetScreenOffTime),
63 DECLARE_NAPI_FUNCTION("getScreenOffTime", GetScreenOffTime),
64 DECLARE_NAPI_FUNCTION("setPowerPolicy", SetPowerPolicy),
65 DECLARE_NAPI_FUNCTION("getPowerPolicy", GetPowerPolicy),
66 DECLARE_NAPI_FUNCTION("installUserCertificate", InstallUserCertificate),
67 DECLARE_NAPI_FUNCTION("uninstallUserCertificate", UninstallUserCertificate),
68 DECLARE_NAPI_PROPERTY("PowerScene", nTimeOut),
69 DECLARE_NAPI_PROPERTY("PowerPolicyAction", nPolicyAction),
70 };
71 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
72 return exports;
73 }
74
SetPowerPolicy(napi_env env,napi_callback_info info)75 napi_value DeviceSettingsAddon::SetPowerPolicy(napi_env env, napi_callback_info info)
76 {
77 EDMLOGI("NAPI_SetPowerPolicy called");
78 size_t argc = ARGS_SIZE_THREE;
79 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
80 napi_value thisArg = nullptr;
81 void *data = nullptr;
82 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
83 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
84 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
85 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter number error");
86 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_object), "parameter object error");
87
88 OHOS::AppExecFwk::ElementName elementName;
89 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
90 "element name param error");
91 PowerScene powerScene;
92 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToPowerScene(env, argv[ARR_INDEX_ONE], powerScene),
93 "power scene param error");
94 PowerPolicy powerPolicy;
95 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToPowerPolicy(env, argv[ARR_INDEX_TWO], powerPolicy),
96 "power policy param error");
97 int32_t ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->SetPowerPolicy(elementName, powerScene, powerPolicy);
98 if (FAILED(ret)) {
99 napi_throw(env, CreateError(env, ret));
100 EDMLOGE("SetPowerPolicy failed!");
101 }
102 return nullptr;
103 }
104
GetPowerPolicy(napi_env env,napi_callback_info info)105 napi_value DeviceSettingsAddon::GetPowerPolicy(napi_env env, napi_callback_info info)
106 {
107 EDMLOGI("NAPI_GetPowerPolicy 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_number), "parameter number 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 PowerScene powerScene;
120 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToPowerScene(env, argv[ARR_INDEX_ONE], powerScene),
121 "power scene param error");
122 PowerPolicy powerPolicy;
123 int32_t ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->GetPowerPolicy(elementName, powerScene, powerPolicy);
124 if (FAILED(ret)) {
125 napi_throw(env, CreateError(env, ret));
126 EDMLOGE("SetPowerPolicy failed!");
127 return nullptr;
128 }
129 napi_value result = ConvertPolicyPolicyToJs(env, powerPolicy);
130 return result;
131 }
132
JsObjToPowerScene(napi_env env,napi_value object,PowerScene & powerScene)133 bool DeviceSettingsAddon::JsObjToPowerScene(napi_env env, napi_value object, PowerScene &powerScene)
134 {
135 uint32_t powerInt = 0;
136 if (ParseUint(env, powerInt, object) && powerInt == static_cast<uint32_t>(PowerScene::TIME_OUT)) {
137 powerScene = PowerScene(powerInt);
138 return true;
139 }
140 return false;
141 }
142
JsObjToPowerPolicy(napi_env env,napi_value object,PowerPolicy & powerPolicy)143 bool DeviceSettingsAddon::JsObjToPowerPolicy(napi_env env, napi_value object, PowerPolicy &powerPolicy)
144 {
145 uint32_t action = 0;
146 if (!JsObjectToUint(env, object, "powerPolicyAction", true, action)) {
147 EDMLOGE("SetPowerPolicy powerPolicyAction parse error!");
148 return false;
149 }
150 uint32_t delayTime = 0;
151 if (!JsObjectToUint(env, object, "delayTime", true, delayTime)) {
152 EDMLOGE("SetPowerPolicy delayTime parse error!");
153 return false;
154 }
155 powerPolicy.SetDelayTime(delayTime);
156 if (!powerPolicy.SetPowerPolicyAction(action)) {
157 return false;
158 }
159 return true;
160 }
161
ConvertPolicyPolicyToJs(napi_env env,PowerPolicy & powerPolicy)162 napi_value DeviceSettingsAddon::ConvertPolicyPolicyToJs(napi_env env, PowerPolicy &powerPolicy)
163 {
164 napi_value result = nullptr;
165 NAPI_CALL(env, napi_create_object(env, &result));
166 napi_value action = nullptr;
167 NAPI_CALL(env, napi_create_uint32(env, static_cast<uint32_t>(powerPolicy.GetPowerPolicyAction()), &action));
168 napi_value delayTime = nullptr;
169 NAPI_CALL(env, napi_create_uint32(env, powerPolicy.GetDealyTime(), &delayTime));
170 NAPI_CALL(env, napi_set_named_property(env, result, "powerPolicyAction", action));
171 NAPI_CALL(env, napi_set_named_property(env, result, "delayTime", delayTime));
172 return result;
173 }
174
SetScreenOffTime(napi_env env,napi_callback_info info)175 napi_value DeviceSettingsAddon::SetScreenOffTime(napi_env env, napi_callback_info info)
176 {
177 EDMLOGI("NAPI_SetScreenOffTime called");
178 size_t argc = ARGS_SIZE_TWO;
179 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
180 napi_value thisArg = nullptr;
181 void *data = nullptr;
182 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
183 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
184 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
185 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter number error");
186
187 auto asyncCallbackInfo = new (std::nothrow) AsyncScreenOffTimeCallbackInfo();
188 if (asyncCallbackInfo == nullptr) {
189 return nullptr;
190 }
191 std::unique_ptr<AsyncScreenOffTimeCallbackInfo> callbackPtr{asyncCallbackInfo};
192 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
193 "element name param error");
194 EDMLOGD(
195 "SetScreenOffTime: asyncCallbackInfo->elementName.bundlename %{public}s, "
196 "asyncCallbackInfo->abilityname:%{public}s",
197 asyncCallbackInfo->elementName.GetBundleName().c_str(),
198 asyncCallbackInfo->elementName.GetAbilityName().c_str());
199 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->time, argv[ARR_INDEX_ONE]),
200 "element name param error");
201 EDMLOGD("SetScreenOffTime time = %{public}d", asyncCallbackInfo->time);
202 asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->SetScreenOffTime(
203 asyncCallbackInfo->elementName, asyncCallbackInfo->time);
204 if (FAILED(asyncCallbackInfo->ret)) {
205 napi_throw(env, CreateError(env, asyncCallbackInfo->ret));
206 EDMLOGE("SetScreenOffTime failed!");
207 }
208 return nullptr;
209 }
210
GetScreenOffTime(napi_env env,napi_callback_info info)211 napi_value DeviceSettingsAddon::GetScreenOffTime(napi_env env, napi_callback_info info)
212 {
213 EDMLOGI("NAPI_GetScreenOffTime called");
214 size_t argc = ARGS_SIZE_TWO;
215 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
216 napi_value thisArg = nullptr;
217 void *data = nullptr;
218 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
219 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
220 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
221 if (argc > ARGS_SIZE_ONE) {
222 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
223 }
224 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
225 auto asyncCallbackInfo = new (std::nothrow) AsyncScreenOffTimeCallbackInfo();
226 if (asyncCallbackInfo == nullptr) {
227 return nullptr;
228 }
229 std::unique_ptr<AsyncScreenOffTimeCallbackInfo> callbackPtr{asyncCallbackInfo};
230 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
231 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
232 EDMLOGD(
233 "GetScreenOffTime: asyncCallbackInfo->elementName.bundlename %{public}s, "
234 "asyncCallbackInfo->abilityname:%{public}s",
235 asyncCallbackInfo->elementName.GetBundleName().c_str(),
236 asyncCallbackInfo->elementName.GetAbilityName().c_str());
237 if (argc > ARGS_SIZE_ONE) {
238 EDMLOGD("GetScreenOffTime argc == ARGS_SIZE_TWO");
239 napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
240 }
241 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetScreenOffTime", NativeGetScreenOffTime,
242 NativeNumberCallbackComplete);
243 callbackPtr.release();
244 return asyncWorkReturn;
245 }
246
NativeGetScreenOffTime(napi_env env,void * data)247 void DeviceSettingsAddon::NativeGetScreenOffTime(napi_env env, void *data)
248 {
249 EDMLOGI("NAPI_NativeGetScreenOffTime called");
250 if (data == nullptr) {
251 EDMLOGE("data is nullptr");
252 return;
253 }
254 AsyncScreenOffTimeCallbackInfo *asyncCallbackInfo = static_cast<AsyncScreenOffTimeCallbackInfo *>(data);
255 asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->GetScreenOffTime(
256 asyncCallbackInfo->elementName, asyncCallbackInfo->intRet);
257 }
258
InstallUserCertificate(napi_env env,napi_callback_info info)259 napi_value DeviceSettingsAddon::InstallUserCertificate(napi_env env, napi_callback_info info)
260 {
261 EDMLOGI("NAPI_InstallUserCertificate called");
262 size_t argc = ARGS_SIZE_THREE;
263 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
264 napi_value thisArg = nullptr;
265 void *data = nullptr;
266 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
267 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
268 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
269 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter want error");
270 matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
271 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter certblob error");
272 if (argc > ARGS_SIZE_TWO) {
273 matchFlag = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
274 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter callback error");
275 }
276 auto asyncCallbackInfo = new (std::nothrow) AsyncCertCallbackInfo();
277 if (asyncCallbackInfo == nullptr) {
278 return nullptr;
279 }
280 std::unique_ptr<AsyncCertCallbackInfo> callbackPtr{asyncCallbackInfo};
281 bool retAdmin = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
282 ASSERT_AND_THROW_PARAM_ERROR(env, retAdmin, "element name param error");
283 EDMLOGD(
284 "InstallUserCertificate: asyncCallbackInfo->elementName.bundlename %{public}s, "
285 "asyncCallbackInfo->abilityname:%{public}s",
286 asyncCallbackInfo->elementName.GetBundleName().c_str(),
287 asyncCallbackInfo->elementName.GetAbilityName().c_str());
288
289 bool retCertBlob = ParseCertBlob(env, argv[ARR_INDEX_ONE], asyncCallbackInfo);
290 ASSERT_AND_THROW_PARAM_ERROR(env, retCertBlob, "element cert blob error");
291
292 if (argc > ARGS_SIZE_TWO) {
293 napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
294 }
295 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "InstallUserCertificate",
296 NativeInstallUserCertificate, NativeStringCallbackComplete);
297 callbackPtr.release();
298 return asyncWorkReturn;
299 }
300
NativeInstallUserCertificate(napi_env env,void * data)301 void DeviceSettingsAddon::NativeInstallUserCertificate(napi_env env, void *data)
302 {
303 EDMLOGI("NAPI_NativeInstallUserCertificate called");
304 if (data == nullptr) {
305 EDMLOGE("data is nullptr");
306 return;
307 }
308 AsyncCertCallbackInfo *asyncCallbackInfo = static_cast<AsyncCertCallbackInfo *>(data);
309 asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->InstallUserCertificate(
310 asyncCallbackInfo->elementName, asyncCallbackInfo->certArray, asyncCallbackInfo->alias,
311 asyncCallbackInfo->stringRet, asyncCallbackInfo->innerCodeMsg);
312 }
313
UninstallUserCertificate(napi_env env,napi_callback_info info)314 napi_value DeviceSettingsAddon::UninstallUserCertificate(napi_env env, napi_callback_info info)
315 {
316 EDMLOGI("NAPI_UninstallUserCertificate called");
317 size_t argc = ARGS_SIZE_THREE;
318 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
319 napi_value thisArg = nullptr;
320 void *data = nullptr;
321 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
322 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
323 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
324 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter want error");
325 matchFlag = MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
326 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter uri error");
327 if (argc > ARGS_SIZE_TWO) {
328 matchFlag = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
329 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter callback error");
330 }
331 auto asyncCallbackInfo = new (std::nothrow) AsyncCertCallbackInfo();
332 if (asyncCallbackInfo == nullptr) {
333 return nullptr;
334 }
335 std::unique_ptr<AsyncCertCallbackInfo> callbackPtr{asyncCallbackInfo};
336 bool retAdmin = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
337 ASSERT_AND_THROW_PARAM_ERROR(env, retAdmin, "element name param error");
338 EDMLOGD(
339 "UninstallUserCertificate: asyncCallbackInfo->elementName.bundlename %{public}s, "
340 "asyncCallbackInfo->abilityname:%{public}s",
341 asyncCallbackInfo->elementName.GetBundleName().c_str(),
342 asyncCallbackInfo->elementName.GetAbilityName().c_str());
343
344 bool retAlias = ParseString(env, asyncCallbackInfo->alias, argv[ARR_INDEX_ONE]);
345 ASSERT_AND_THROW_PARAM_ERROR(env, retAlias, "element alias error");
346
347 if (argc > ARGS_SIZE_TWO) {
348 napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
349 }
350 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "uninstallUserCertificate",
351 NativeUninstallUserCertificate, NativeVoidCallbackComplete);
352 callbackPtr.release();
353 return asyncWorkReturn;
354 }
355
NativeUninstallUserCertificate(napi_env env,void * data)356 void DeviceSettingsAddon::NativeUninstallUserCertificate(napi_env env, void *data)
357 {
358 EDMLOGI("NAPI_NativeUninstallUserCertificate called");
359 if (data == nullptr) {
360 EDMLOGE("data is nullptr");
361 return;
362 }
363 AsyncCertCallbackInfo *asyncCallbackInfo = static_cast<AsyncCertCallbackInfo *>(data);
364 asyncCallbackInfo->ret = DeviceSettingsProxy::GetDeviceSettingsProxy()->UninstallUserCertificate(
365 asyncCallbackInfo->elementName, asyncCallbackInfo->alias, asyncCallbackInfo->innerCodeMsg);
366 }
367
ParseCertBlob(napi_env env,napi_value object,AsyncCertCallbackInfo * asyncCertCallbackInfo)368 bool DeviceSettingsAddon::ParseCertBlob(napi_env env, napi_value object, AsyncCertCallbackInfo *asyncCertCallbackInfo)
369 {
370 napi_valuetype type = napi_undefined;
371 NAPI_CALL_BASE(env, napi_typeof(env, object, &type), false);
372 if (type != napi_object) {
373 EDMLOGE("type of param certblob is not object");
374 return false;
375 }
376 if (!JsObjectToU8Vector(env, object, "inData", asyncCertCallbackInfo->certArray)) {
377 EDMLOGE("uint8Array to vector failed");
378 return false;
379 }
380 return JsObjectToString(env, object, "alias", true, asyncCertCallbackInfo->alias);
381 }
382
383 static napi_module g_deviceSettingsModule = {
384 .nm_version = 1,
385 .nm_flags = 0,
386 .nm_filename = nullptr,
387 .nm_register_func = DeviceSettingsAddon::Init,
388 .nm_modname = "enterprise.deviceSettings",
389 .nm_priv = ((void *)0),
390 .reserved = {0},
391 };
392
DeviceSettingsRegister()393 extern "C" __attribute__((constructor)) void DeviceSettingsRegister()
394 {
395 napi_module_register(&g_deviceSettingsModule);
396 }