1 /*
2  * Copyright (c) 2021-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 <cstdint>
16 
17 #include "ipc_skeleton.h"
18 #include "js_plugin_callback.h"
19 #include "js_plugin_callback_mgr.h"
20 #include "js_plugin_util.h"
21 #include "js_plugin_want.h"
22 #include "napi/native_api.h"
23 #include "napi/native_node_api.h"
24 #include "tokenid_kit.h"
25 
26 #include "base/log/log_wrapper.h"
27 #include "core/components/plugin/plugin_component_manager.h"
28 
29 namespace OHOS::Ace::Napi {
30 constexpr int ACE_ARGS_MAX_COUNT = 10;
31 constexpr int ACE_ARGS_TWO = 2;
32 constexpr int ACE_ARGS_THREE = 3;
33 constexpr int ACE_PARAM0 = 0;
34 constexpr int ACE_PARAM1 = 1;
35 constexpr int ACE_PARAM2 = 2;
36 constexpr int NAPI_ACE_ERR_ERROR = 1;
37 
UnwrapStageWantFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)38 bool UnwrapStageWantFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
39 {
40     if (!AceUnwrapWant(env, param, asyncCallbackInfo->wantStage)) {
41         return false;
42     }
43     return true;
44 }
45 
UnwrapOwnerWantFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)46 bool UnwrapOwnerWantFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
47 {
48     napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, "owner", napi_object);
49     if (jsValue == nullptr) {
50         return false;
51     }
52 
53     if (!AceUnwrapWant(env, jsValue, asyncCallbackInfo->wantStage)) {
54         return false;
55     }
56 
57     auto selfToken = IPCSkeleton::GetSelfTokenID();
58     if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
59         TAG_LOGI(AceLogTag::ACE_PLUGIN_COMPONENT, "This application is not system-app, can not use system-api");
60         return false;
61     }
62 
63     return true;
64 }
65 
UnwrapWantFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)66 bool UnwrapWantFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
67 {
68     napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, "want", napi_object);
69     if (jsValue == nullptr) {
70         return false;
71     }
72 
73     if (!AceUnwrapWant(env, jsValue, asyncCallbackInfo->jsParamList.want)) {
74         return false;
75     }
76     return true;
77 }
78 
UnwrapTargetFromJS(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)79 bool UnwrapTargetFromJS(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
80 {
81     napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, "target", napi_object);
82     if (jsValue == nullptr) {
83         return false;
84     }
85 
86     if (!AceUnwrapWant(env, jsValue, asyncCallbackInfo->jsParamList.want)) {
87         return false;
88     }
89     return true;
90 }
91 
UnwrapNameFromJS(napi_env env,napi_value param,const std::string & key,ACEAsyncJSCallbackInfo * asyncCallbackInfo)92 bool UnwrapNameFromJS(napi_env env, napi_value param, const std::string& key, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
93 {
94     napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, key.c_str(), napi_string);
95     if (jsValue == nullptr) {
96         return false;
97     }
98 
99     std::string strValue = AceUnwrapStringFromJS(env, jsValue);
100     asyncCallbackInfo->jsParamList.paramList.PutStringValue(key, strValue);
101     return true;
102 }
103 
UnwrapKVObjectFromJS(napi_env env,napi_value param,const std::string & key,ACEAsyncJSCallbackInfo * asyncCallbackInfo)104 bool UnwrapKVObjectFromJS(
105     napi_env env, napi_value param, const std::string& key, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
106 {
107     napi_value jsValue = AceGetPropertyValueByPropertyName(env, param, key.c_str(), napi_object);
108     if (jsValue == nullptr) {
109         return false;
110     }
111 
112     std::string jsonString("{}");
113     bool ret = AceKVObjectToString(env, jsValue, jsonString);
114     if (ret) {
115         asyncCallbackInfo->jsParamList.paramList.PutStringValue(key, jsonString);
116     }
117     return ret;
118 }
119 
UnwrapPushParameters(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)120 bool UnwrapPushParameters(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
121 {
122     if (!AceIsTypeForNapiValue(env, param, napi_object)) {
123         return false;
124     }
125 
126     bool isStageModelAPI = (asyncCallbackInfo->ability == nullptr);
127     if (isStageModelAPI) {
128         if (!UnwrapOwnerWantFromJS(env, param, asyncCallbackInfo)) {
129             return false;
130         }
131     }
132 
133     if (!UnwrapWantFromJS(env, param, asyncCallbackInfo) && !UnwrapTargetFromJS(env, param, asyncCallbackInfo)) {
134         return false;
135     }
136     if (!UnwrapNameFromJS(env, param, "name", asyncCallbackInfo)) {
137         return false;
138     }
139     if (!UnwrapKVObjectFromJS(env, param, "data", asyncCallbackInfo)) {
140         return false;
141     }
142     if (!UnwrapKVObjectFromJS(env, param, "extraData", asyncCallbackInfo)) {
143         return false;
144     }
145 
146     UnwrapNameFromJS(env, param, "jsonPath", asyncCallbackInfo);
147     return true;
148 }
149 
UnwrapParamForPush(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)150 bool UnwrapParamForPush(napi_env env, size_t argc, napi_value* argv, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
151 {
152     const size_t argcMax = ACE_ARGS_TWO;
153     if (argc <= 0 || argc > argcMax) {
154         return false;
155     }
156 
157     if (!UnwrapPushParameters(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
158         return false;
159     }
160 
161     if (argc == argcMax) {
162         if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
163             return false;
164         }
165     }
166     return true;
167 }
168 
JSPushCompleteAsyncCallbackWork(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)169 void JSPushCompleteAsyncCallbackWork(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
170 {
171     if (asyncCallbackInfo == nullptr) {
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, asyncCallbackInfo);
182 }
183 
JSPushCompletePromiseCallbackWork(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)184 void JSPushCompletePromiseCallbackWork(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
185 {
186     if (asyncCallbackInfo == nullptr) {
187         return;
188     }
189 
190     PluginComponentManager::GetInstance()->Push(asyncCallbackInfo->jsParamList.want,
191         asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
192         asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"),
193         asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"),
194         asyncCallbackInfo->jsParamList.paramList.GetStringValue("extraData"));
195 
196     asyncCallbackInfo->error_code = 0;
197     AceCompletePromiseCallbackWork(env, asyncCallbackInfo);
198 }
199 
NAPI_JSPushWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)200 napi_value NAPI_JSPushWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
201 {
202     size_t argc = ACE_ARGS_MAX_COUNT;
203     napi_value args[ACE_ARGS_MAX_COUNT] = { nullptr };
204     napi_value jsthis = 0;
205     void* data = nullptr;
206 
207     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
208     if (!UnwrapParamForPush(env, argc, args, asyncCallbackInfo)) {
209         return nullptr;
210     }
211 
212     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
213         JSPushCompleteAsyncCallbackWork(env, asyncCallbackInfo);
214         return AceWrapVoidToJS(env);
215     } else {
216         napi_value promise = 0;
217         NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
218         JSPushCompletePromiseCallbackWork(env, asyncCallbackInfo);
219         return promise;
220     }
221 }
222 
JSPush(napi_env env,napi_callback_info info)223 static napi_value JSPush(napi_env env, napi_callback_info info)
224 {
225     ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
226     if (asyncCallbackInfo == nullptr) {
227         return AceWrapVoidToJS(env);
228     }
229 
230     napi_value rev = NAPI_JSPushWrap(env, info, asyncCallbackInfo);
231     if (rev == nullptr) {
232         AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
233         rev = AceWrapVoidToJS(env);
234     }
235     return rev;
236 }
237 
UnwrapRequestParameters(napi_env env,napi_value param,ACEAsyncJSCallbackInfo * asyncCallbackInfo)238 bool UnwrapRequestParameters(napi_env env, napi_value param, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
239 {
240     if (!AceIsTypeForNapiValue(env, param, napi_object)) {
241         return false;
242     }
243 
244     bool isStageModelAPI = (asyncCallbackInfo->ability == nullptr);
245     if (isStageModelAPI) {
246         if (!UnwrapOwnerWantFromJS(env, param, asyncCallbackInfo)) {
247             return false;
248         }
249     }
250 
251     if (!UnwrapWantFromJS(env, param, asyncCallbackInfo) && !UnwrapTargetFromJS(env, param, asyncCallbackInfo)) {
252         return false;
253     }
254     if (!UnwrapNameFromJS(env, param, "name", asyncCallbackInfo)) {
255         return false;
256     }
257     if (!UnwrapKVObjectFromJS(env, param, "data", asyncCallbackInfo)) {
258         return false;
259     }
260 
261     UnwrapNameFromJS(env, param, "jsonPath", asyncCallbackInfo);
262     return true;
263 }
264 
UnwrapParamForRequest(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)265 bool UnwrapParamForRequest(napi_env env, size_t argc, napi_value* argv, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
266 {
267     if (argc <= 0 || argc > ACE_ARGS_TWO) {
268         return false;
269     }
270 
271     if (!UnwrapRequestParameters(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
272         return false;
273     }
274 
275     if (argc == ACE_ARGS_TWO) {
276         if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
277             return false;
278         }
279     }
280     return true;
281 }
282 
AceRequestCompleteAsyncCallbackWork(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)283 void AceRequestCompleteAsyncCallbackWork(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
284 {
285     if (asyncCallbackInfo == nullptr) {
286         return;
287     }
288 
289     if (asyncCallbackInfo->ability != nullptr) {
290         std::shared_ptr<AAFwk::Want> pWant = asyncCallbackInfo->ability->GetWant();
291         asyncCallbackInfo->wantStage = *pWant;
292     } else {
293         int32_t pid = IPCSkeleton::GetCallingPid();
294         asyncCallbackInfo->wantStage.SetBundle("plugin" + std::to_string(pid));
295     }
296 
297     std::shared_ptr<AceJSPluginRequestParam> param = std::make_shared<AceJSPluginRequestParam>(
298         asyncCallbackInfo->jsParamList.want, asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
299         asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"),
300         asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"));
301     if (param != nullptr) {
302         TAG_LOGD(AceLogTag::ACE_PLUGIN_COMPONENT, "Want = %{public}s:%{public}s",
303             asyncCallbackInfo->wantStage.GetElement().GetBundleName().c_str(),
304             asyncCallbackInfo->wantStage.GetElement().GetAbilityName().c_str());
305         bool ret = JSPluginCallbackMgr::Instance().RegisterRequestEvent(
306             env, asyncCallbackInfo->wantStage, asyncCallbackInfo->cbInfo, param);
307         if (ret) {
308             asyncCallbackInfo->cbInfo.callback = nullptr;
309         }
310     }
311 
312     PluginComponentManager::GetInstance()->Request(asyncCallbackInfo->jsParamList.want,
313         asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
314         asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"),
315         asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"));
316 
317     AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
318 }
319 
MakePluginTemplateObject(napi_env env,const PluginComponentTemplate & pluginTemplate)320 napi_value MakePluginTemplateObject(napi_env env, const PluginComponentTemplate& pluginTemplate)
321 {
322     napi_value jsPluginTemplate = AceCreateJSObject(env);
323     if (jsPluginTemplate != nullptr) {
324         napi_value jsSource = AceWrapStringToJS(env, pluginTemplate.GetSource());
325         napi_value jsAbility = AceWrapStringToJS(env, pluginTemplate.GetAbility());
326 
327         AceSetPropertyValueByPropertyName(env, jsPluginTemplate, "source", jsSource);
328         AceSetPropertyValueByPropertyName(env, jsPluginTemplate, "ability", jsAbility);
329     }
330     return jsPluginTemplate;
331 }
332 
MakeCallbackParamForRequest(napi_env env,const PluginComponentTemplate & pluginTemplate,const ACEAsyncJSCallbackInfo * asyncCallbackInfo)333 napi_value MakeCallbackParamForRequest(
334     napi_env env, const PluginComponentTemplate& pluginTemplate, const ACEAsyncJSCallbackInfo* asyncCallbackInfo)
335 {
336     napi_value jsObject = AceCreateJSObject(env);
337     if (jsObject == nullptr) {
338         return nullptr;
339     }
340     std::string dataTmp("{}");
341     std::string extraDataTmp("{}");
342     if (!asyncCallbackInfo->requestCallbackData.data.empty()) {
343         dataTmp = asyncCallbackInfo->requestCallbackData.data;
344     }
345     if (!asyncCallbackInfo->requestCallbackData.extraData.empty()) {
346         extraDataTmp = asyncCallbackInfo->requestCallbackData.extraData;
347     }
348 
349     napi_value jsPluginTemplate = MakePluginTemplateObject(env, pluginTemplate);
350     napi_value jsData = AceStringToKVObject(env, dataTmp);
351     napi_value jsExtraData = AceStringToKVObject(env, extraDataTmp);
352 
353     if (jsData != nullptr) {
354         AceSetPropertyValueByPropertyName(env, jsObject, "componentTemplate", jsPluginTemplate);
355     }
356     if (jsData != nullptr) {
357         AceSetPropertyValueByPropertyName(env, jsObject, "data", jsData);
358     }
359     if (jsExtraData != nullptr) {
360         AceSetPropertyValueByPropertyName(env, jsObject, "extraData", jsExtraData);
361     }
362     return jsObject;
363 }
364 
TransferRequestCallBackData(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)365 napi_value TransferRequestCallBackData(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
366 {
367     PluginComponentTemplate componentTemplate;
368     componentTemplate.SetSource(asyncCallbackInfo->requestCallbackData.sourceName);
369     componentTemplate.SetAbility(asyncCallbackInfo->requestCallbackData.abilityName);
370     napi_value jsResult = MakeCallbackParamForRequest(env, componentTemplate, asyncCallbackInfo);
371     return jsResult;
372 }
373 
AceRequestPromiseAsyncCallbackWork(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)374 void AceRequestPromiseAsyncCallbackWork(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
375 {
376     if (asyncCallbackInfo == nullptr) {
377         return;
378     }
379 
380     if (asyncCallbackInfo->ability != nullptr) {
381         std::shared_ptr<AAFwk::Want> pWant = asyncCallbackInfo->ability->GetWant();
382         asyncCallbackInfo->wantStage = *pWant;
383     } else {
384         int32_t pid = IPCSkeleton::GetCallingPid();
385         asyncCallbackInfo->wantStage.SetBundle("plugin" + std::to_string(pid));
386     }
387 
388     std::shared_ptr<AceJSPluginRequestParam> param = std::make_shared<AceJSPluginRequestParam>(
389         asyncCallbackInfo->jsParamList.want, asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
390         asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"),
391         asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"));
392     asyncCallbackInfo->onRequestCallbackOK = false;
393 
394     if (param != nullptr) {
395         TAG_LOGD(AceLogTag::ACE_PLUGIN_COMPONENT, "Want = %{public}s:%{public}s",
396             asyncCallbackInfo->wantStage.GetElement().GetBundleName().c_str(),
397             asyncCallbackInfo->wantStage.GetElement().GetAbilityName().c_str());
398         JSPluginCallbackMgr::Instance().RegisterRequestEvent(
399             env, asyncCallbackInfo->wantStage, asyncCallbackInfo, param);
400     }
401 
402     PluginComponentManager::GetInstance()->Request(asyncCallbackInfo->jsParamList.want,
403         asyncCallbackInfo->jsParamList.paramList.GetStringValue("name"),
404         asyncCallbackInfo->jsParamList.paramList.GetStringValue("jsonPath"),
405         asyncCallbackInfo->jsParamList.paramList.GetStringValue("data"));
406 
407     if (asyncCallbackInfo->onRequestCallbackOK) {
408         asyncCallbackInfo->error_code = 0;
409         napi_resolve_deferred(env, asyncCallbackInfo->deferred, TransferRequestCallBackData(env, asyncCallbackInfo));
410         AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
411     } else {
412         asyncCallbackInfo->error_code = NAPI_ACE_ERR_ERROR;
413         AceCompletePromiseCallbackWork(env, asyncCallbackInfo);
414     }
415 }
416 
NAPI_JSRequestWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)417 napi_value NAPI_JSRequestWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
418 {
419     size_t argc = ACE_ARGS_MAX_COUNT;
420     napi_value args[ACE_ARGS_MAX_COUNT] = { nullptr };
421     napi_value jsthis = 0;
422     void* data = nullptr;
423 
424     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
425 
426     if (!UnwrapParamForRequest(env, argc, args, asyncCallbackInfo)) {
427         return nullptr;
428     }
429 
430     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
431         AceRequestCompleteAsyncCallbackWork(env, asyncCallbackInfo);
432         return AceWrapVoidToJS(env);
433     } else {
434         napi_value promise = 0;
435         NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
436         AceRequestPromiseAsyncCallbackWork(env, asyncCallbackInfo);
437         return promise;
438     }
439 }
440 
JSRequest(napi_env env,napi_callback_info info)441 static napi_value JSRequest(napi_env env, napi_callback_info info)
442 {
443     ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
444     if (asyncCallbackInfo == nullptr) {
445         return AceWrapVoidToJS(env);
446     }
447 
448     napi_value rev = NAPI_JSRequestWrap(env, info, asyncCallbackInfo);
449     if (rev == nullptr) {
450         AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
451         rev = AceWrapVoidToJS(env);
452     }
453     return rev;
454 }
455 
UnwrapParamForOn(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)456 bool UnwrapParamForOn(napi_env env, size_t argc, napi_value* argv, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
457 {
458     const size_t argcMax = ACE_ARGS_THREE;
459     if (argc > argcMax || argc < ACE_ARGS_TWO) {
460         return false;
461     }
462 
463     if (argc == ACE_ARGS_THREE) {
464         if (!UnwrapStageWantFromJS(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
465             return false;
466         }
467 
468         std::string eventName = AceUnwrapStringFromJS(env, argv[ACE_PARAM1]);
469         if (eventName == "push" || eventName == "request") {
470             asyncCallbackInfo->jsParamList.paramList.PutStringValue("eventName", eventName);
471         } else {
472             return false;
473         }
474 
475         if (!AceCreateAsyncCallback(env, argv[ACE_PARAM2], asyncCallbackInfo)) {
476             return false;
477         }
478     } else {
479         std::string eventName = AceUnwrapStringFromJS(env, argv[ACE_PARAM0]);
480         if (eventName == "push" || eventName == "request") {
481             asyncCallbackInfo->jsParamList.paramList.PutStringValue("eventName", eventName);
482         } else {
483             return false;
484         }
485 
486         if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
487             return false;
488         }
489     }
490     return true;
491 }
492 
AceOnCompleteAsyncCallbackWork(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)493 void AceOnCompleteAsyncCallbackWork(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
494 {
495     if (asyncCallbackInfo == nullptr) {
496         return;
497     }
498 
499     std::string eventName = asyncCallbackInfo->jsParamList.paramList.GetStringValue("eventName");
500     CallBackType eventCallbackType = CallBackType::PushEvent;
501     if (eventName == "request") {
502         eventCallbackType = CallBackType::RequestEvent;
503     }
504 
505     if (asyncCallbackInfo->ability != nullptr) {
506         std::shared_ptr<AAFwk::Want> pWant = asyncCallbackInfo->ability->GetWant();
507         asyncCallbackInfo->wantStage = *pWant;
508     } else {
509         int32_t pid = IPCSkeleton::GetCallingPid();
510         asyncCallbackInfo->wantStage.SetBundle("plugin" + std::to_string(pid));
511     }
512 
513     bool ret = JSPluginCallbackMgr::Instance().RegisterOnEvent(
514         env, eventCallbackType, asyncCallbackInfo->wantStage, asyncCallbackInfo->cbInfo);
515     if (ret) {
516         asyncCallbackInfo->cbInfo.callback = nullptr;
517     }
518     AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
519 }
520 
NAPI_JSOnWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)521 napi_value NAPI_JSOnWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
522 {
523     size_t argc = ACE_ARGS_MAX_COUNT;
524     napi_value args[ACE_ARGS_MAX_COUNT] = { nullptr };
525     napi_value jsthis = 0;
526     void* data = nullptr;
527 
528     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
529 
530     if (!UnwrapParamForOn(env, argc, args, asyncCallbackInfo)) {
531         return nullptr;
532     }
533 
534     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
535         AceOnCompleteAsyncCallbackWork(env, asyncCallbackInfo);
536         return AceWrapVoidToJS(env);
537     } else {
538         return nullptr;
539     }
540 }
541 
JSOn(napi_env env,napi_callback_info info)542 static napi_value JSOn(napi_env env, napi_callback_info info)
543 {
544     ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
545     if (asyncCallbackInfo == nullptr) {
546         return AceWrapVoidToJS(env);
547     }
548 
549     napi_value rev = NAPI_JSOnWrap(env, info, asyncCallbackInfo);
550     if (rev == nullptr) {
551         AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
552         rev = AceWrapVoidToJS(env);
553     }
554     return rev;
555 }
556 
UnwrapParamForOff(napi_env env,size_t argc,napi_value * argv,ACEAsyncJSCallbackInfo * asyncCallbackInfo)557 bool UnwrapParamForOff(napi_env env, size_t argc, napi_value* argv, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
558 {
559     if (argc != ACE_ARGS_TWO) {
560         return false;
561     }
562 
563     if (!UnwrapStageWantFromJS(env, argv[ACE_PARAM0], asyncCallbackInfo)) {
564         return false;
565     }
566 
567     if (!AceCreateAsyncCallback(env, argv[ACE_PARAM1], asyncCallbackInfo)) {
568         return false;
569     }
570 
571     return true;
572 }
573 
AceOffCompleteAsyncCallbackWork(napi_env env,ACEAsyncJSCallbackInfo * asyncCallbackInfo)574 void AceOffCompleteAsyncCallbackWork(napi_env env, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
575 {
576     if (asyncCallbackInfo == nullptr) {
577         return;
578     }
579 
580     JSPluginCallbackMgr::Instance().UnregisterCallBack(env, asyncCallbackInfo->wantStage);
581     AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
582 }
583 
NAPI_JSOffWrap(napi_env env,napi_callback_info info,ACEAsyncJSCallbackInfo * asyncCallbackInfo)584 napi_value NAPI_JSOffWrap(napi_env env, napi_callback_info info, ACEAsyncJSCallbackInfo* asyncCallbackInfo)
585 {
586     size_t argc = ACE_ARGS_MAX_COUNT;
587     napi_value args[ACE_ARGS_MAX_COUNT] = { nullptr };
588     napi_value jsthis = 0;
589     void* data = nullptr;
590 
591     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
592 
593     if (!UnwrapParamForOff(env, argc, args, asyncCallbackInfo)) {
594         return nullptr;
595     }
596 
597     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
598         AceOffCompleteAsyncCallbackWork(env, asyncCallbackInfo);
599         return AceWrapVoidToJS(env);
600     } else {
601         return nullptr;
602     }
603 }
604 
JSOff(napi_env env,napi_callback_info info)605 static napi_value JSOff(napi_env env, napi_callback_info info)
606 {
607     ACEAsyncJSCallbackInfo* asyncCallbackInfo = AceCreateAsyncJSCallbackInfo(env);
608     if (asyncCallbackInfo == nullptr) {
609         return AceWrapVoidToJS(env);
610     }
611 
612     napi_value rev = NAPI_JSOffWrap(env, info, asyncCallbackInfo);
613     if (rev == nullptr) {
614         AceFreeAsyncJSCallbackInfo(&asyncCallbackInfo);
615         rev = AceWrapVoidToJS(env);
616     }
617     return rev;
618 }
619 
PluginComponentEventTypeInit(napi_env env,napi_value exports)620 napi_value PluginComponentEventTypeInit(napi_env env, napi_value exports)
621 {
622     napi_value obj = nullptr;
623     napi_create_object(env, &obj);
624 
625     AceSetNamedPropertyByString(env, obj, "push", "EVENT_TYPE_PUSH");
626     AceSetNamedPropertyByString(env, obj, "request", "EVENT_TYPE_REQUEST");
627 
628     napi_property_descriptor properties[] = {
629         DECLARE_NAPI_PROPERTY("EventType", obj),
630     };
631 
632     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
633     return exports;
634 }
635 
PluginComponentInit(napi_env env,napi_value exports)636 napi_value PluginComponentInit(napi_env env, napi_value exports)
637 {
638     napi_property_descriptor properties[] = {
639         DECLARE_NAPI_FUNCTION("push", JSPush),
640         DECLARE_NAPI_FUNCTION("request", JSRequest),
641         DECLARE_NAPI_FUNCTION("on", JSOn),
642         DECLARE_NAPI_FUNCTION("off", JSOff),
643     };
644 
645     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
646     return exports;
647 }
648 
PluginComponentExport(napi_env env,napi_value exports)649 static napi_value PluginComponentExport(napi_env env, napi_value exports)
650 {
651     PluginComponentEventTypeInit(env, exports);
652     PluginComponentInit(env, exports);
653     return exports;
654 }
655 
656 static napi_module PlugInComonentModule = {
657     .nm_version = 1,
658     .nm_flags = 0,
659     .nm_filename = nullptr,
660     .nm_register_func = PluginComponentExport,
661     .nm_modname = "pluginComponent",
662     .nm_priv = ((void*)0),
663     .reserved = { 0 },
664 };
665 
RegisterPluginComponent()666 extern "C" __attribute__((constructor)) void RegisterPluginComponent()
667 {
668     napi_module_register(&PlugInComonentModule);
669 }
670 } // namespace OHOS::Ace::Napi
671