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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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, &paramsCount, 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