1 /*
2 * Copyright (c) 2021-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 "module_template.h"
17
18 #include <algorithm>
19 #include <functional>
20 #include <initializer_list>
21 #include <memory>
22 #include <new>
23 #include <string>
24
25 #include "event_manager.h"
26 #include "netstack_log.h"
27
28 namespace OHOS::NetStack::ModuleTemplate {
29 static constexpr const int EVENT_PARAM_NUM = 2;
30 static constexpr const char *INTERFACE_LOCAL_SOCKET = "LocalSocket";
31 static constexpr const char *INTERFACE_TLS_SOCKET = "TLSSocket";
32 static constexpr const char *INTERFACE_WEB_SOCKET = "WebSocket";
33 static constexpr const char *INTERFACE_HTTP_REQUEST = "OHOS_NET_HTTP_HttpRequest";
34
OnManagerWrapper(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)35 napi_value OnManagerWrapper(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events,
36 bool asyncCallback)
37 {
38 napi_value thisVal = nullptr;
39 size_t paramsCount = MAX_PARAM_NUM;
40 napi_value params[MAX_PARAM_NUM] = {nullptr};
41 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
42
43 if (paramsCount != EVENT_PARAM_NUM || NapiUtils::GetValueType(env, params[0]) != napi_string ||
44 NapiUtils::GetValueType(env, params[1]) != napi_function) {
45 NETSTACK_LOGE("on off once interface para: [string, function]");
46 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
47 return NapiUtils::GetUndefined(env);
48 }
49
50 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
51 if (std::find(events.begin(), events.end(), event) == events.end()) {
52 return NapiUtils::GetUndefined(env);
53 }
54
55 EventManagerWrapper *wrapper = nullptr;
56 auto napiRet = napi_unwrap(env, thisVal, reinterpret_cast<void **>(&wrapper));
57 if (napiRet != napi_ok) {
58 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
59 return NapiUtils::GetUndefined(env);
60 }
61 if (wrapper == nullptr) {
62 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
63 return NapiUtils::GetUndefined(env);
64 }
65 auto manager = wrapper->sharedManager;
66 if (manager == nullptr) {
67 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
68 return NapiUtils::GetUndefined(env);
69 }
70 if (manager != nullptr) {
71 manager->AddListener(env, event, params[1], false, asyncCallback);
72 }
73
74 return NapiUtils::GetUndefined(env);
75 }
76
OnceManagerWrapper(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)77 napi_value OnceManagerWrapper(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events,
78 bool asyncCallback)
79 {
80 napi_value thisVal = nullptr;
81 size_t paramsCount = MAX_PARAM_NUM;
82 napi_value params[MAX_PARAM_NUM] = {nullptr};
83 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
84
85 if (paramsCount != EVENT_PARAM_NUM || NapiUtils::GetValueType(env, params[0]) != napi_string ||
86 NapiUtils::GetValueType(env, params[1]) != napi_function) {
87 NETSTACK_LOGE("on off once interface para: [string, function]");
88 return NapiUtils::GetUndefined(env);
89 }
90
91 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
92 if (std::find(events.begin(), events.end(), event) == events.end()) {
93 return NapiUtils::GetUndefined(env);
94 }
95
96 EventManagerWrapper *wrapper = nullptr;
97 auto napiRet = napi_unwrap(env, thisVal, reinterpret_cast<void **>(&wrapper));
98 if (napiRet != napi_ok) {
99 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
100 return NapiUtils::GetUndefined(env);
101 }
102 if (wrapper == nullptr) {
103 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
104 return NapiUtils::GetUndefined(env);
105 }
106 auto manager = wrapper->sharedManager;
107 if (manager != nullptr) {
108 manager->AddListener(env, event, params[1], true, asyncCallback);
109 }
110
111 return NapiUtils::GetUndefined(env);
112 }
113
OffManagerWrapper(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events)114 napi_value OffManagerWrapper(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events)
115 {
116 napi_value thisVal = nullptr;
117 size_t paramsCount = MAX_PARAM_NUM;
118 napi_value params[MAX_PARAM_NUM] = {nullptr};
119 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
120
121 if ((paramsCount != 1 && paramsCount != EVENT_PARAM_NUM) ||
122 NapiUtils::GetValueType(env, params[0]) != napi_string) {
123 NETSTACK_LOGE("on off once interface para: [string, function?]");
124 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
125 return NapiUtils::GetUndefined(env);
126 }
127
128 if (paramsCount == EVENT_PARAM_NUM && NapiUtils::GetValueType(env, params[1]) != napi_function) {
129 NETSTACK_LOGE("on off once interface para: [string, function]");
130 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
131 return NapiUtils::GetUndefined(env);
132 }
133
134 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
135 if (std::find(events.begin(), events.end(), event) == events.end()) {
136 return NapiUtils::GetUndefined(env);
137 }
138
139 EventManagerWrapper *wrapper = nullptr;
140 auto napiRet = napi_unwrap(env, thisVal, reinterpret_cast<void **>(&wrapper));
141 if (napiRet != napi_ok) {
142 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
143 return NapiUtils::GetUndefined(env);
144 }
145 if (wrapper == nullptr) {
146 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
147 return NapiUtils::GetUndefined(env);
148 }
149 auto manager = wrapper->sharedManager;
150 if (manager == nullptr) {
151 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
152 return NapiUtils::GetUndefined(env);
153 }
154 if (manager != nullptr) {
155 if (paramsCount == EVENT_PARAM_NUM) {
156 manager->DeleteListener(event, params[1]);
157 } else {
158 manager->DeleteListener(event);
159 }
160 }
161
162 return NapiUtils::GetUndefined(env);
163 }
164
OnSharedManager(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)165 napi_value OnSharedManager(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events,
166 bool asyncCallback)
167 {
168 napi_value thisVal = nullptr;
169 size_t paramsCount = MAX_PARAM_NUM;
170 napi_value params[MAX_PARAM_NUM] = {nullptr};
171 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
172
173 if (paramsCount != EVENT_PARAM_NUM || NapiUtils::GetValueType(env, params[0]) != napi_string ||
174 NapiUtils::GetValueType(env, params[1]) != napi_function) {
175 NETSTACK_LOGE("on off once interface para: [string, function]");
176 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
177 return NapiUtils::GetUndefined(env);
178 }
179
180 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
181 if (std::find(events.begin(), events.end(), event) == events.end()) {
182 return NapiUtils::GetUndefined(env);
183 }
184
185 std::shared_ptr<EventManager> *sharedManager = nullptr;
186 auto napiRet = napi_unwrap(env, thisVal, reinterpret_cast<void **>(&sharedManager));
187 if (napiRet != napi_ok) {
188 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
189 return NapiUtils::GetUndefined(env);
190 }
191 if (sharedManager == nullptr) {
192 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
193 return NapiUtils::GetUndefined(env);
194 }
195 auto manager = *sharedManager;
196 if (manager == nullptr) {
197 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
198 return NapiUtils::GetUndefined(env);
199 }
200 if (manager != nullptr) {
201 manager->AddListener(env, event, params[1], false, asyncCallback);
202 }
203
204 return NapiUtils::GetUndefined(env);
205 }
206
OnceSharedManager(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)207 napi_value OnceSharedManager(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events,
208 bool asyncCallback)
209 {
210 napi_value thisVal = nullptr;
211 size_t paramsCount = MAX_PARAM_NUM;
212 napi_value params[MAX_PARAM_NUM] = {nullptr};
213 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
214
215 if (paramsCount != EVENT_PARAM_NUM || NapiUtils::GetValueType(env, params[0]) != napi_string ||
216 NapiUtils::GetValueType(env, params[1]) != napi_function) {
217 NETSTACK_LOGE("on off once interface para: [string, function]");
218 return NapiUtils::GetUndefined(env);
219 }
220
221 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
222 if (std::find(events.begin(), events.end(), event) == events.end()) {
223 return NapiUtils::GetUndefined(env);
224 }
225
226 std::shared_ptr<EventManager> *sharedManager = nullptr;
227 auto napiRet = napi_unwrap(env, thisVal, reinterpret_cast<void **>(&sharedManager));
228 if (napiRet != napi_ok) {
229 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
230 return NapiUtils::GetUndefined(env);
231 }
232 if (sharedManager == nullptr) {
233 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
234 return NapiUtils::GetUndefined(env);
235 }
236 auto manager = *sharedManager;
237 if (manager != nullptr) {
238 manager->AddListener(env, event, params[1], true, asyncCallback);
239 }
240
241 return NapiUtils::GetUndefined(env);
242 }
243
OffSharedManager(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events)244 napi_value OffSharedManager(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events)
245 {
246 napi_value thisVal = nullptr;
247 size_t paramsCount = MAX_PARAM_NUM;
248 napi_value params[MAX_PARAM_NUM] = {nullptr};
249 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
250
251 if ((paramsCount != 1 && paramsCount != EVENT_PARAM_NUM) ||
252 NapiUtils::GetValueType(env, params[0]) != napi_string) {
253 NETSTACK_LOGE("on off once interface para: [string, function?]");
254 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
255 return NapiUtils::GetUndefined(env);
256 }
257
258 if (paramsCount == EVENT_PARAM_NUM && NapiUtils::GetValueType(env, params[1]) != napi_function) {
259 NETSTACK_LOGE("on off once interface para: [string, function]");
260 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
261 return NapiUtils::GetUndefined(env);
262 }
263
264 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
265 if (std::find(events.begin(), events.end(), event) == events.end()) {
266 return NapiUtils::GetUndefined(env);
267 }
268
269 std::shared_ptr<EventManager> *sharedManager = nullptr;
270 auto napiRet = napi_unwrap(env, thisVal, reinterpret_cast<void **>(&sharedManager));
271 if (napiRet != napi_ok) {
272 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
273 return NapiUtils::GetUndefined(env);
274 }
275 if (sharedManager == nullptr) {
276 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
277 return NapiUtils::GetUndefined(env);
278 }
279 auto manager = *sharedManager;
280 if (manager == nullptr) {
281 NETSTACK_LOGE("get event manager in napi_unwrap failed, napiRet is %{public}d", napiRet);
282 return NapiUtils::GetUndefined(env);
283 }
284 if (manager != nullptr) {
285 if (paramsCount == EVENT_PARAM_NUM) {
286 manager->DeleteListener(event, params[1]);
287 } else {
288 manager->DeleteListener(event);
289 }
290 }
291
292 return NapiUtils::GetUndefined(env);
293 }
294
On(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)295 napi_value On(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events,
296 bool asyncCallback)
297 {
298 napi_value thisVal = nullptr;
299 size_t paramsCount = MAX_PARAM_NUM;
300 napi_value params[MAX_PARAM_NUM] = {nullptr};
301 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
302
303 if (paramsCount != EVENT_PARAM_NUM || NapiUtils::GetValueType(env, params[0]) != napi_string ||
304 NapiUtils::GetValueType(env, params[1]) != napi_function) {
305 NETSTACK_LOGE("on off once interface para: [string, function]");
306 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
307 return NapiUtils::GetUndefined(env);
308 }
309
310 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
311 if (std::find(events.begin(), events.end(), event) == events.end()) {
312 return NapiUtils::GetUndefined(env);
313 }
314
315 EventManager *manager = nullptr;
316 napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager));
317 if (manager != nullptr) {
318 manager->AddListener(env, event, params[1], false, asyncCallback);
319 }
320
321 return NapiUtils::GetUndefined(env);
322 }
323
Once(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events,bool asyncCallback)324 napi_value Once(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events,
325 bool asyncCallback)
326 {
327 napi_value thisVal = nullptr;
328 size_t paramsCount = MAX_PARAM_NUM;
329 napi_value params[MAX_PARAM_NUM] = {nullptr};
330 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
331
332 if (paramsCount != EVENT_PARAM_NUM || NapiUtils::GetValueType(env, params[0]) != napi_string ||
333 NapiUtils::GetValueType(env, params[1]) != napi_function) {
334 NETSTACK_LOGE("on off once interface para: [string, function]");
335 return NapiUtils::GetUndefined(env);
336 }
337
338 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
339 if (std::find(events.begin(), events.end(), event) == events.end()) {
340 return NapiUtils::GetUndefined(env);
341 }
342
343 EventManager *manager = nullptr;
344 napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager));
345 if (manager != nullptr) {
346 manager->AddListener(env, event, params[1], true, asyncCallback);
347 }
348
349 return NapiUtils::GetUndefined(env);
350 }
351
Off(napi_env env,napi_callback_info info,const std::initializer_list<std::string> & events)352 napi_value Off(napi_env env, napi_callback_info info, const std::initializer_list<std::string> &events)
353 {
354 napi_value thisVal = nullptr;
355 size_t paramsCount = MAX_PARAM_NUM;
356 napi_value params[MAX_PARAM_NUM] = {nullptr};
357 NAPI_CALL(env, napi_get_cb_info(env, info, ¶msCount, params, &thisVal, nullptr));
358
359 if ((paramsCount != 1 && paramsCount != EVENT_PARAM_NUM) ||
360 NapiUtils::GetValueType(env, params[0]) != napi_string) {
361 NETSTACK_LOGE("on off once interface para: [string, function?]");
362 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
363 return NapiUtils::GetUndefined(env);
364 }
365
366 if (paramsCount == EVENT_PARAM_NUM && NapiUtils::GetValueType(env, params[1]) != napi_function) {
367 NETSTACK_LOGE("on off once interface para: [string, function]");
368 napi_throw_error(env, std::to_string(PARSE_ERROR_CODE).c_str(), PARSE_ERROR_MSG);
369 return NapiUtils::GetUndefined(env);
370 }
371
372 std::string event = NapiUtils::GetStringFromValueUtf8(env, params[0]);
373 if (std::find(events.begin(), events.end(), event) == events.end()) {
374 return NapiUtils::GetUndefined(env);
375 }
376
377 EventManager *manager = nullptr;
378 napi_unwrap(env, thisVal, reinterpret_cast<void **>(&manager));
379 if (manager != nullptr) {
380 if (paramsCount == EVENT_PARAM_NUM) {
381 manager->DeleteListener(event, params[1]);
382 } else {
383 manager->DeleteListener(event);
384 }
385 }
386
387 return NapiUtils::GetUndefined(env);
388 }
389
DefineClass(napi_env env,napi_value exports,const std::initializer_list<napi_property_descriptor> & properties,const std::string & className)390 void DefineClass(napi_env env, napi_value exports, const std::initializer_list<napi_property_descriptor> &properties,
391 const std::string &className)
392 {
393 auto constructor = [](napi_env env, napi_callback_info info) -> napi_value {
394 napi_value thisVal = nullptr;
395 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVal, nullptr));
396
397 return thisVal;
398 };
399
400 napi_value jsConstructor = nullptr;
401
402 napi_property_descriptor descriptors[properties.size()];
403 std::copy(properties.begin(), properties.end(), descriptors);
404
405 NAPI_CALL_RETURN_VOID(env, napi_define_class(env, className.c_str(), NAPI_AUTO_LENGTH, constructor, nullptr,
406 properties.size(), descriptors, &jsConstructor));
407 (void)exports;
408 auto global = NapiUtils::GetGlobal(env);
409 NapiUtils::SetNamedProperty(env, global, className, jsConstructor);
410 }
411
NewInstanceWithManagerWrapper(napi_env env,napi_callback_info info,const std::string & className,Finalizer finalizer)412 napi_value NewInstanceWithManagerWrapper(napi_env env, napi_callback_info info, const std::string &className,
413 Finalizer finalizer)
414 {
415 NETSTACK_LOGD("create new instance for %{public}s", className.c_str());
416 napi_value thisVal = nullptr;
417 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVal, nullptr));
418
419 auto global = NapiUtils::GetGlobal(env);
420 napi_value jsConstructor = NapiUtils::GetNamedProperty(env, global, className);
421 if (NapiUtils::GetValueType(env, jsConstructor) == napi_undefined) {
422 return nullptr;
423 }
424
425 napi_value result = nullptr;
426 NAPI_CALL(env, napi_new_instance(env, jsConstructor, 0, nullptr, &result));
427
428 auto wrapper = new EventManagerWrapper;
429 auto manager = std::make_shared<EventManager>();
430 wrapper->sharedManager = manager;
431 if (className == INTERFACE_HTTP_REQUEST || className == INTERFACE_LOCAL_SOCKET ||
432 className == INTERFACE_TLS_SOCKET || className == INTERFACE_WEB_SOCKET) {
433 NETSTACK_LOGD("create reference for %{public}s", className.c_str());
434 manager->CreateEventReference(env, thisVal);
435 }
436 napi_wrap(env, result, reinterpret_cast<void *>(wrapper), finalizer, nullptr, nullptr);
437
438 return result;
439 }
440
NewInstanceWithSharedManager(napi_env env,napi_callback_info info,const std::string & className,Finalizer finalizer)441 napi_value NewInstanceWithSharedManager(napi_env env, napi_callback_info info, const std::string &className,
442 Finalizer finalizer)
443 {
444 NETSTACK_LOGD("create new instance for %{public}s", className.c_str());
445 napi_value thisVal = nullptr;
446 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVal, nullptr));
447
448 auto global = NapiUtils::GetGlobal(env);
449 napi_value jsConstructor = NapiUtils::GetNamedProperty(env, global, className);
450 if (NapiUtils::GetValueType(env, jsConstructor) == napi_undefined) {
451 return nullptr;
452 }
453
454 napi_value result = nullptr;
455 NAPI_CALL(env, napi_new_instance(env, jsConstructor, 0, nullptr, &result));
456
457 auto sharedManager = new (std::nothrow) std::shared_ptr<EventManager>();
458 if (sharedManager == nullptr) {
459 return result;
460 }
461 auto manager = std::make_shared<EventManager>();
462 *sharedManager = manager;
463 if (className == INTERFACE_HTTP_REQUEST || className == INTERFACE_LOCAL_SOCKET ||
464 className == INTERFACE_TLS_SOCKET || className == INTERFACE_WEB_SOCKET) {
465 NETSTACK_LOGD("create reference for %{public}s", className.c_str());
466 manager->CreateEventReference(env, thisVal);
467 }
468 napi_wrap(env, result, reinterpret_cast<void *>(sharedManager), finalizer, nullptr, nullptr);
469
470 return result;
471 }
472
NewInstance(napi_env env,napi_callback_info info,const std::string & className,Finalizer finalizer)473 napi_value NewInstance(napi_env env, napi_callback_info info, const std::string &className, Finalizer finalizer)
474 {
475 NETSTACK_LOGD("create new instance for %{public}s", className.c_str());
476 napi_value thisVal = nullptr;
477 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVal, nullptr));
478
479 auto global = NapiUtils::GetGlobal(env);
480 napi_value jsConstructor = NapiUtils::GetNamedProperty(env, global, className);
481 if (NapiUtils::GetValueType(env, jsConstructor) == napi_undefined) {
482 return nullptr;
483 }
484
485 napi_value result = nullptr;
486 NAPI_CALL(env, napi_new_instance(env, jsConstructor, 0, nullptr, &result));
487
488 auto manager = new EventManager();
489 EventManager::SetValid(manager);
490 if (className == INTERFACE_HTTP_REQUEST || className == INTERFACE_LOCAL_SOCKET ||
491 className == INTERFACE_TLS_SOCKET || className == INTERFACE_WEB_SOCKET) {
492 NETSTACK_LOGD("create reference for %{public}s", className.c_str());
493 manager->CreateEventReference(env, thisVal);
494 }
495 napi_wrap(env, result, reinterpret_cast<void *>(manager), finalizer, nullptr, nullptr);
496
497 return result;
498 }
499
NewInstanceNoManager(napi_env env,napi_callback_info info,const std::string & name,Finalizer finalizer)500 napi_value NewInstanceNoManager(napi_env env, napi_callback_info info, const std::string &name, Finalizer finalizer)
501 {
502 napi_value thisVal = nullptr;
503 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &thisVal, nullptr));
504 (void)thisVal;
505 auto global = NapiUtils::GetGlobal(env);
506 napi_value jsConstructor = NapiUtils::GetNamedProperty(env, global, name);
507 if (NapiUtils::GetValueType(env, jsConstructor) == napi_undefined) {
508 return nullptr;
509 }
510
511 napi_value result = nullptr;
512 NAPI_CALL(env, napi_new_instance(env, jsConstructor, 0, nullptr, &result));
513
514 return result;
515 }
516 } // namespace OHOS::NetStack::ModuleTemplate
517