1 /*
2 * Copyright (c) 2021 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 "hilog_wrapper.h"
16 #include "js_plugin_callback.h"
17 #include "js_plugin_callback_mgr.h"
18 #include "js_plugin_util.h"
19 #include "js_plugin_want.h"
20 #include "napi/native_api.h"
21 #include "napi/native_node_api.h"
22
23 #include "core/components/plugin/plugin_component_manager.h"
24
25 namespace OHOS::Ace::Napi {
26 constexpr int ACE_ARGS_MAX_COUNT = 10;
27 constexpr int ACE_ARGS_TWO = 2;
28 constexpr int ACE_ARGS_THREE = 3;
29 constexpr int ACE_PARAM0 = 0;
30 constexpr int ACE_PARAM1 = 1;
31 constexpr int ACE_PARAM2 = 2;
32
UnwrapStageWantFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)33 bool UnwrapStageWantFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
34 {
35 if (!AceUnwrapWant(env, param, asyncCallbackInfo->wantStage)) {
36 HILOG_INFO("%{public}s called, Params(want stage) is invalid.", __func__);
37 return false;
38 }
39 return true;
40 }
41
UnwrapOwnerWantFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)42 bool UnwrapOwnerWantFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
43 {
44 napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, "owner", napi_object);
45 if (jsValue == nullptr) {
46 HILOG_INFO("%{public}s called, Params(want) is not object.", __func__);
47 return false;
48 }
49
50 if (!AceUnwrapWant(env, jsValue, asyncCallbackInfo->wantStage)) {
51 HILOG_INFO("%{public}s called, Params(want) is invalid.", __func__);
52 return false;
53 }
54 return true;
55 }
56
UnwrapWantFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)57 bool UnwrapWantFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
58 {
59 napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, "want", napi_object);
60 if (jsValue == nullptr) {
61 HILOG_INFO("%{public}s called, Params(want) is not object.", __func__);
62 return false;
63 }
64
65 if (!AceUnwrapWant(env, jsValue, asyncCallbackInfo->jsParamList.want)) {
66 HILOG_INFO("%{public}s called, Params(want) is invalid.", __func__);
67 return false;
68 }
69 return true;
70 }
71
UnwrapNameFromJS(napi_env env,napi_value param,const std::string & key,ACEAsyncJSCallbackInfo * asyncCallbackInfo)72 bool UnwrapNameFromJS(napi_env env, napi_value param, const std::string& key,
73 ACEAsyncJSCallbackInfo* asyncCallbackInfo)
74 {
75 napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, key.c_str(), napi_string);
76 if (jsValue == nullptr) {
77 HILOG_INFO("%{public}s called, Params(%{public}s) is not string.", __func__, key.c_str());
78 return false;
79 }
80
81 std::string strValue = AceUnwrapStringFromJS(env, jsValue);
82 asyncCallbackInfo->jsParamList.paramList.PutStringValue(key, strValue);
83 return true;
84 }
85
UnwrapKVObjectFromJS(napi_env env,napi_value param,const std::string & key,ACEAsyncJSCallbackInfo * asyncCallbackInfo)86 bool UnwrapKVObjectFromJS(napi_env env, napi_value param, const std::string& key,
87 ACEAsyncJSCallbackInfo* asyncCallbackInfo)
88 {
89 napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, key.c_str(), napi_object);
90 if (jsValue == nullptr) {
91 HILOG_INFO("%{public}s called, Params(%{public}s) is not object.", __func__, key.c_str());
92 return false;
93 }
94
95 std::string jsonString("{}");
96 bool ret = AceKVObjectToString(env, jsValue, jsonString);
97 if (ret) {
98 asyncCallbackInfo->jsParamList.paramList.PutStringValue(key, jsonString);
99 }
100 return ret;
101 }
102
UnwrapPushParameters(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)103 bool UnwrapPushParameters(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
104 {
105 if (!AceIsTypeForNapiValue(env, param, napi_object)) {
106 HILOG_INFO("%{public}s called, Params is invalid.", __func__);
107 return false;
108 }
109
110 bool isStageModelAPI = (asyncCallbackInfo->ability == nullptr);
111 if (isStageModelAPI) {
112 if (!UnwrapOwnerWantFromJS(env, param, asyncCallbackInfo)) {
113 HILOG_INFO("%{public}s called, Params(ownerWant) is invalid.", __func__);
114 return false;
115 }
116 }
117
118 if (!UnwrapWantFromJS(env, param, asyncCallbackInfo)) {
119 HILOG_INFO("%{public}s called, Params(want) is invalid.", __func__);
120 return false;
121 }
122 if (!UnwrapNameFromJS(env, param, "name", asyncCallbackInfo)) {
123 HILOG_INFO("%{public}s called, Params(name) is invalid.", __func__);
124 return false;
125 }
126 if (!UnwrapKVObjectFromJS(env, param, "data", asyncCallbackInfo)) {
127 HILOG_INFO("%{public}s called, Params(data) is invalid.", __func__);
128 return false;
129 }
130 if (!UnwrapKVObjectFromJS(env, param, "extraData", asyncCallbackInfo)) {
131 HILOG_INFO("%{public}s called, Params(data) is invalid.", __func__);
132 return false;
133 }
134
135 UnwrapNameFromJS(env, param, "jsonPath", asyncCallbackInfo);
136 return true;
137 }
138
UnwrapParamForPush(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)139 bool UnwrapParamForPush(napi_env env, size_t argc, napi_value* argv,
140 ACEAsyncJSCallbackInfo* asyncCallbackInfo)
141 {
142 HILOG_INFO("%{public}s called, argc=%{public}zu", __func__, argc);
143 const size_t argcMax = ACE_ARGS_TWO;
144 if (argc != argcMax) {
145 HILOG_INFO("%{public}s called, Params is invalid.", __func__);
146 return false;
147 }
148
149 if (!UnwrapPushParameters(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
150 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
151 return false;
152 }
153
154 if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
155 HILOG_INFO("%{public}s called, the last parameter is invalid.", __func__);
156 return false;
157 }
158 return true;
159 }
160
JSPushWork(napi_env env,void * data)161 void JSPushWork(napi_env env, void* data)
162 {
163 HILOG_INFO("%{public}s called.", __func__);
164 }
165
JSPushCompleteAsyncCallbackWork(napi_env env,napi_status status,void * data)166 void JSPushCompleteAsyncCallbackWork(napi_env env, napi_status status, void* data)
167 {
168 HILOG_INFO("%{public}s called.", __func__);
169 ACEAsyncJSCallbackInfo* asyncCallbackInfo = (ACEAsyncJSCallbackInfo*)data;
170 if (asyncCallbackInfo == nullptr) {
171 HILOG_INFO("%{public}s called. asyncCallbackInfo is null", __func__);
172 return;
173 }
174 PluginComponentManager::GetInstance()->Push(asyncCallbackInfo->jsParamList.want,
175 asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
176 asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"),
177 asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"),
178 asyncCallbackInfo->jsParamList.paramList.GetStringValue("extraData"));
179
180 asyncCallbackInfo->error_code = 0;
181 AceCompleteAsyncCallbackWork(env, status, data);
182 }
183
NAPI_JSPushWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)184 napi_value NAPI_JSPushWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
185 {
186 HILOG_INFO("%{public}s called.", __func__);
187 size_t argc = ACE_ARGS_MAX_COUNT;
188 napi_value args[ACE_ARGS_MAX_COUNT] = {nullptr};
189 napi_value jsthis = 0;
190 void* data = nullptr;
191
192 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
193 if (!UnwrapParamForPush(env, argc, args, asyncCallbackInfo)) {
194 HILOG_INFO("%{public}s called. Invoke UnwrapParamForPush fail", __func__);
195 return nullptr;
196 }
197 ACEAsyncParamEx asyncParamEx;
198 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
199 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
200 asyncParamEx.resource = "NAPI_JSPushCallback";
201 asyncParamEx.execute = JSPushWork;
202 asyncParamEx.complete = JSPushCompleteAsyncCallbackWork;
203
204 return AceExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
205 } else {
206 HILOG_INFO("%{public}s called. promise.", __func__);
207 asyncParamEx.resource = "NAPI_JSPushPromise";
208 return nullptr;
209 }
210 }
211
JSPush(napi_env env,napi_callback_info info)212 static napi_value JSPush(napi_env env, napi_callback_info info)
213 {
214 HILOG_INFO("%{public}s called.", __func__);
215
216 ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
217 if (asyncCallbackInfo == nullptr) {
218 return AceWrapVoidToJS(env);
219 }
220
221 napi_value rev = NAPI_JSPushWrap(env, info, asyncCallbackInfo);
222 if (rev == nullptr) {
223 AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
224 rev = AceWrapVoidToJS(env);
225 }
226 return rev;
227 }
228
UnwrapRequestParameters(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)229 bool UnwrapRequestParameters(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
230 {
231 if (!AceIsTypeForNapiValue(env, param, napi_object)) {
232 HILOG_INFO("%{public}s called, Params is invalid.", __func__);
233 return false;
234 }
235
236 bool isStageModelAPI = (asyncCallbackInfo->ability == nullptr);
237 if (isStageModelAPI) {
238 if (!UnwrapOwnerWantFromJS(env, param, asyncCallbackInfo)) {
239 HILOG_INFO("%{public}s called, Params(ownerWant) is invalid.", __func__);
240 return false;
241 }
242 }
243
244 if (!UnwrapWantFromJS(env, param, asyncCallbackInfo)) {
245 HILOG_INFO("%{public}s called, Params(want) is invalid.", __func__);
246 return false;
247 }
248 if (!UnwrapNameFromJS(env, param, "name", asyncCallbackInfo)) {
249 HILOG_INFO("%{public}s called, Params(name) is invalid.", __func__);
250 return false;
251 }
252 if (!UnwrapKVObjectFromJS(env, param, "data", asyncCallbackInfo)) {
253 HILOG_INFO("%{public}s called, Params(data) is invalid.", __func__);
254 return false;
255 }
256
257 UnwrapNameFromJS(env, param, "jsonPath", asyncCallbackInfo);
258 return true;
259 }
260
UnwrapParamForRequest(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)261 bool UnwrapParamForRequest(napi_env env, size_t argc, napi_value* argv,
262 ACEAsyncJSCallbackInfo* asyncCallbackInfo)
263 {
264 HILOG_INFO("%{public}s called, argc=%{public}zu", __func__, argc);
265 if (argc != ACE_ARGS_TWO) {
266 HILOG_INFO("%{public}s called, Params is invalid.", __func__);
267 return false;
268 }
269
270 if (!UnwrapRequestParameters(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
271 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
272 return false;
273 }
274
275 if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
276 HILOG_INFO("%{public}s called, the last parameter is invalid.", __func__);
277 return false;
278 }
279 return true;
280 }
281
JSRequestWork(napi_env env,void * data)282 void JSRequestWork(napi_env env, void* data)
283 {
284 HILOG_INFO("%{public}s called.", __func__);
285 }
286
AceRequestCompleteAsyncCallbackWork(napi_env env,napi_status status,void * data)287 void AceRequestCompleteAsyncCallbackWork(napi_env env, napi_status status, void* data)
288 {
289 HILOG_INFO("%{public}s called.", __func__);
290
291 ACEAsyncJSCallbackInfo* asyncCallbackInfo = (ACEAsyncJSCallbackInfo*)data;
292 if (asyncCallbackInfo == nullptr) {
293 HILOG_INFO("%{public}s called, asyncCallbackInfo is null", __func__);
294 return;
295 }
296
297 if (asyncCallbackInfo->ability != nullptr) {
298 std::shared_ptr<AAFwk::Want> pWant = asyncCallbackInfo->ability->GetWant();
299 asyncCallbackInfo->wantStage = *pWant;
300 }
301
302 std::shared_ptr<AceJSPluginRequestParam> param = std::make_shared<AceJSPluginRequestParam>(
303 asyncCallbackInfo->jsParamList.want,
304 asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
305 asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"),
306 asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath")
307 );
308 if (param != nullptr) {
309 HILOG_INFO("%{public}s called, pWant = %{public}s:%{public}s",
310 __func__, asyncCallbackInfo->wantStage.GetElement().GetBundleName().c_str(),
311 asyncCallbackInfo->wantStage.GetElement().GetAbilityName().c_str());
312 bool ret = JSPluginCallbackMgr::Instance().RegisterRequestEvent(env, asyncCallbackInfo->wantStage,
313 asyncCallbackInfo->cbInfo, param);
314 if (ret) {
315 asyncCallbackInfo->cbInfo.callback = nullptr;
316 }
317 }
318
319 PluginComponentManager::GetInstance()->Request(asyncCallbackInfo->jsParamList.want,
320 asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
321 asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"),
322 asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"));
323
324 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
325 AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
326 }
327
NAPI_JSRequestWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)328 napi_value NAPI_JSRequestWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
329 {
330 HILOG_INFO("%{public}s called.", __func__);
331 size_t argc = ACE_ARGS_MAX_COUNT;
332 napi_value args[ACE_ARGS_MAX_COUNT] = {nullptr};
333 napi_value jsthis = 0;
334 void* data = nullptr;
335
336 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
337
338 if (!UnwrapParamForRequest(env, argc, args, asyncCallbackInfo)) {
339 HILOG_INFO("%{public}s called. Invoke UnwrapParamForRequest fail", __func__);
340 return nullptr;
341 }
342
343 ACEAsyncParamEx asyncParamEx;
344 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
345 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
346 asyncParamEx.resource = "NAPI_JSRequestCallback";
347 asyncParamEx.execute = JSRequestWork;
348 asyncParamEx.complete = AceRequestCompleteAsyncCallbackWork;
349 return AceExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
350 } else {
351 HILOG_INFO("%{public}s called. promise.", __func__);
352 asyncParamEx.resource = "NAPI_JSRequestPromise";
353 return nullptr;
354 }
355 }
356
JSRequest(napi_env env,napi_callback_info info)357 static napi_value JSRequest(napi_env env, napi_callback_info info)
358 {
359 HILOG_INFO("%{public}s called.", __func__);
360
361 ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
362 if (asyncCallbackInfo == nullptr) {
363 return AceWrapVoidToJS(env);
364 }
365
366 napi_value rev = NAPI_JSRequestWrap(env, info, asyncCallbackInfo);
367 if (rev == nullptr) {
368 AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
369 rev = AceWrapVoidToJS(env);
370 }
371 return rev;
372 }
373
UnwrapParamForOn(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)374 bool UnwrapParamForOn(napi_env env, size_t argc, napi_value* argv,
375 ACEAsyncJSCallbackInfo* asyncCallbackInfo)
376 {
377 HILOG_INFO("%{public}s called, argc=%{public}zu", __func__, argc);
378
379 const size_t argcMax = ACE_ARGS_THREE;
380 if (argc > argcMax || argc < ACE_ARGS_TWO) {
381 HILOG_INFO("%{public}s called, Params is invalid.", __func__);
382 return false;
383 }
384
385 if (asyncCallbackInfo->ability == nullptr && argc != ACE_ARGS_THREE) {
386 HILOG_INFO("%{public}s called, Params is invalid.", __func__);
387 return false;
388 }
389
390 if (argc == ACE_ARGS_THREE || asyncCallbackInfo->ability == nullptr) {
391 if (!UnwrapStageWantFromJS(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
392 HILOG_INFO("%{public}s called, the owner want parameter is invalid.", __func__);
393 return false;
394 }
395
396 std::string eventName = AceUnwrapStringFromJS(env, argv[ACE_PARAM1]);
397 if (eventName == "push" || eventName == "request") {
398 asyncCallbackInfo->jsParamList.paramList.PutStringValue("eventName", eventName);
399 } else {
400 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
401 return false;
402 }
403
404 if (!AceCreateAsyncCallback(env, argv[ACE_PARAM2], asyncCallbackInfo)) {
405 HILOG_INFO("%{public}s called, the second parameter is invalid.", __func__);
406 return false;
407 }
408 } else {
409 std::string eventName = AceUnwrapStringFromJS(env, argv[ACE_PARAM0]);
410 if (eventName == "push" || eventName == "request") {
411 asyncCallbackInfo->jsParamList.paramList.PutStringValue("eventName", eventName);
412 } else {
413 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
414 return false;
415 }
416
417 if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
418 HILOG_INFO("%{public}s called, the second parameter is invalid.", __func__);
419 return false;
420 }
421 }
422 return true;
423 }
424
JSOnWork(napi_env env,void * data)425 void JSOnWork(napi_env env, void* data)
426 {
427 HILOG_INFO("%{public}s called.", __func__);
428 }
429
AceOnCompleteAsyncCallbackWork(napi_env env,napi_status status,void * data)430 void AceOnCompleteAsyncCallbackWork(napi_env env, napi_status status, void* data)
431 {
432 HILOG_INFO("%{public}s called.", __func__);
433
434 ACEAsyncJSCallbackInfo* asyncCallbackInfo = (ACEAsyncJSCallbackInfo*)data;
435 if (asyncCallbackInfo == nullptr) {
436 HILOG_INFO("%{public}s called, asyncCallbackInfo is null", __func__);
437 return;
438 }
439
440 std::string eventName = asyncCallbackInfo->jsParamList.paramList.GetStringValue("eventName");
441 CallBackType eventCallbackType = CallBackType::PushEvent;
442 if (eventName == "request") {
443 eventCallbackType = CallBackType::RequestEvent;
444 }
445
446 if (asyncCallbackInfo->ability != nullptr) {
447 std::shared_ptr<AAFwk::Want> pWant = asyncCallbackInfo->ability->GetWant();
448 asyncCallbackInfo->wantStage = *pWant;
449 }
450
451 bool ret = JSPluginCallbackMgr::Instance().RegisterOnEvent(env, eventCallbackType,
452 asyncCallbackInfo->wantStage, asyncCallbackInfo->cbInfo);
453 if (ret) {
454 asyncCallbackInfo->cbInfo.callback = nullptr;
455 }
456 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
457 AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
458 }
459
NAPI_JSOnWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)460 napi_value NAPI_JSOnWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
461 {
462 HILOG_INFO("%{public}s called.", __func__);
463 size_t argc = ACE_ARGS_MAX_COUNT;
464 napi_value args[ACE_ARGS_MAX_COUNT] = {nullptr};
465 napi_value jsthis = 0;
466 void* data = nullptr;
467
468 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
469
470 if (!UnwrapParamForOn(env, argc, args, asyncCallbackInfo)) {
471 HILOG_INFO("%{public}s called. Invoke UnwrapParamForOn fail", __func__);
472 return nullptr;
473 }
474
475 ACEAsyncParamEx asyncParamEx;
476 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
477 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
478 asyncParamEx.resource = "NAPI_JSOCallback";
479 asyncParamEx.execute = JSOnWork;
480 asyncParamEx.complete = AceOnCompleteAsyncCallbackWork;
481
482 return AceExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
483 } else {
484 HILOG_INFO("%{public}s called. promise.", __func__);
485 asyncParamEx.resource = "NAPI_JSOnPromise";
486 return nullptr;
487 }
488 }
489
JSOn(napi_env env,napi_callback_info info)490 static napi_value JSOn(napi_env env, napi_callback_info info)
491 {
492 HILOG_INFO("%{public}s called.", __func__);
493
494 ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
495 if (asyncCallbackInfo == nullptr) {
496 return AceWrapVoidToJS(env);
497 }
498
499 napi_value rev = NAPI_JSOnWrap(env, info, asyncCallbackInfo);
500 if (rev == nullptr) {
501 AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
502 rev = AceWrapVoidToJS(env);
503 }
504 return rev;
505 }
506
PluginComponentExport(napi_env env,napi_value exports)507 static napi_value PluginComponentExport(napi_env env, napi_value exports)
508 {
509 napi_property_descriptor properties[] = {
510 DECLARE_NAPI_FUNCTION("push", JSPush),
511 DECLARE_NAPI_FUNCTION("request", JSRequest),
512 DECLARE_NAPI_FUNCTION("on", JSOn),
513 };
514
515 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
516 return exports;
517 }
518
519 static napi_module PlugInComonentModule = {
520 .nm_version = 1,
521 .nm_flags = 0,
522 .nm_filename = nullptr,
523 .nm_register_func = PluginComponentExport,
524 .nm_modname = "plugincomponent",
525 .nm_priv = ((void*)0),
526 .reserved = { 0 },
527 };
528
RegisterPluginComponent()529 extern "C" __attribute__((constructor)) void RegisterPluginComponent()
530 {
531 napi_module_register(&PlugInComonentModule);
532 }
533 } // namespace OHOS::Ace::Napi
534