1 /*
2  * Copyright (c) 2022-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 
16 #include "napi_common_event.h"
17 
18 #include <mutex>
19 #include <uv.h>
20 
21 #include "ces_inner_error_code.h"
22 #include "event_log_wrapper.h"
23 #include "napi_common.h"
24 #include "node_api.h"
25 #include "support.h"
26 
27 namespace OHOS {
28 namespace EventManagerFwkNapi {
29 using namespace OHOS::EventFwk;
30 using namespace OHOS::Notification;
31 
32 static const int32_t PUBLISH_MAX_PARA = 2;
33 static const int32_t ARGS_TWO_EVENT = 2;
34 static const int32_t INDEX_ZERO = 0;
35 static const uint32_t INDEX_ONE = 1;
36 static const uint32_t ARGC_ONE = 1;
37 static const uint32_t ARGC_TWO = 2;
38 static const int32_t PUBLISH_MAX_PARA_AS_USER = 3;
39 static const int32_t STR_DATA_MAX_SIZE = 64 * 1024;  // 64KB
40 
41 std::atomic_ullong SubscriberInstance::subscriberID_ = 0;
42 
NapiStaicSubscribeInit(napi_env env,napi_value exports)43 static napi_value NapiStaicSubscribeInit(napi_env env, napi_value exports)
44 {
45     EVENT_LOGD("called");
46     if (env == nullptr || exports == nullptr) {
47         EVENT_LOGD("Invalid input parameters");
48         return nullptr;
49     }
50 
51     std::unique_ptr<NapiStaticSubscribe> napiStaicSubscribe = std::make_unique<NapiStaticSubscribe>();
52     napi_wrap(env, exports, napiStaicSubscribe.release(), NapiStaticSubscribe::Finalizer, nullptr, nullptr);
53     const char *moduleName = "NapiStaticSubscribe";
54     AbilityRuntime::BindNativeFunction(
55         env, exports, "setStaticSubscriberState", moduleName, NapiStaticSubscribe::SetStaticSubscriberState);
56 
57     return exports;
58 }
59 
AsyncCallbackInfoUnsubscribe()60 AsyncCallbackInfoUnsubscribe::AsyncCallbackInfoUnsubscribe()
61 {
62     EVENT_LOGD("enter");
63 }
64 
~AsyncCallbackInfoUnsubscribe()65 AsyncCallbackInfoUnsubscribe::~AsyncCallbackInfoUnsubscribe()
66 {
67     EVENT_LOGD("exit");
68 }
69 
ClearEnvCallback(void * data)70 static void ClearEnvCallback(void *data)
71 {
72     EVENT_LOGD("Env expired, need to clear env");
73     SubscriberInstance *subscriber = static_cast<SubscriberInstance *>(data);
74     subscriber->ClearEnv();
75 }
76 
SubscriberInstanceWrapper(const CommonEventSubscribeInfo & info)77 SubscriberInstanceWrapper::SubscriberInstanceWrapper(const CommonEventSubscribeInfo &info)
78 {
79     auto objectInfo = new (std::nothrow) SubscriberInstance(info);
80     if (objectInfo == nullptr) {
81         EVENT_LOGE("objectInfo is null");
82         return;
83     }
84 
85     EVENT_LOGI("Constructor objectInfo");
86     subscriber = std::shared_ptr<SubscriberInstance>(objectInfo);
87 }
88 
GetSubscriber()89 std::shared_ptr<SubscriberInstance> SubscriberInstanceWrapper::GetSubscriber()
90 {
91     return subscriber;
92 }
93 
SetCommonEventData(const CommonEventDataWorker * commonEventDataWorkerData,napi_value & result)94 napi_value SetCommonEventData(const CommonEventDataWorker *commonEventDataWorkerData, napi_value &result)
95 {
96     EVENT_LOGD("enter");
97 
98     if (commonEventDataWorkerData == nullptr) {
99         EVENT_LOGE("commonEventDataWorkerData is nullptr");
100         return nullptr;
101     }
102 
103     napi_value value = nullptr;
104 
105     // event
106     napi_create_string_utf8(commonEventDataWorkerData->env,
107         commonEventDataWorkerData->want.GetAction().c_str(),
108         NAPI_AUTO_LENGTH,
109         &value);
110     napi_set_named_property(commonEventDataWorkerData->env, result, "event", value);
111 
112     // bundleName
113     napi_create_string_utf8(commonEventDataWorkerData->env,
114         commonEventDataWorkerData->want.GetBundle().c_str(),
115         NAPI_AUTO_LENGTH,
116         &value);
117     napi_set_named_property(commonEventDataWorkerData->env, result, "bundleName", value);
118 
119     // code
120     napi_create_int32(commonEventDataWorkerData->env, commonEventDataWorkerData->code, &value);
121     napi_set_named_property(commonEventDataWorkerData->env, result, "code", value);
122 
123     // data
124     napi_create_string_utf8(
125         commonEventDataWorkerData->env, commonEventDataWorkerData->data.c_str(), NAPI_AUTO_LENGTH, &value);
126     napi_set_named_property(commonEventDataWorkerData->env, result, "data", value);
127 
128     // parameters ?: {[key:string] : any}
129     AAFwk::WantParams wantParams = commonEventDataWorkerData->want.GetParams();
130     napi_value wantParamsValue = nullptr;
131     wantParamsValue = OHOS::AppExecFwk::WrapWantParams(commonEventDataWorkerData->env, wantParams);
132     if (wantParamsValue) {
133         napi_set_named_property(commonEventDataWorkerData->env, result, "parameters", wantParamsValue);
134     } else {
135         napi_set_named_property(
136             commonEventDataWorkerData->env, result, "parameters", NapiGetNull(commonEventDataWorkerData->env));
137     }
138 
139     return NapiGetNull(commonEventDataWorkerData->env);
140 }
141 
ThreadSafeCallback(napi_env env,napi_value jsCallback,void * context,void * data)142 void ThreadSafeCallback(napi_env env, napi_value jsCallback, void* context, void* data)
143 {
144     EVENT_LOGD("OnReceiveEvent ThreadSafeCallback excute");
145     CommonEventDataWorker *commonEventDataWorkerData = static_cast<CommonEventDataWorker *>(data);
146     if (commonEventDataWorkerData == nullptr) {
147         EVENT_LOGE("OnReceiveEvent commonEventDataWorkerData is nullptr");
148         return;
149     }
150     if (commonEventDataWorkerData->ref == nullptr ||
151         (commonEventDataWorkerData->valid == nullptr) || *(commonEventDataWorkerData->valid) == false) {
152         EVENT_LOGE("OnReceiveEvent commonEventDataWorkerData ref is null or invalid which may be previously released");
153         delete commonEventDataWorkerData;
154         commonEventDataWorkerData = nullptr;
155         return;
156     }
157     napi_handle_scope scope;
158     napi_open_handle_scope(commonEventDataWorkerData->env, &scope);
159     if (scope == nullptr) {
160         EVENT_LOGE("Scope is null");
161         return;
162     }
163 
164     napi_value result = nullptr;
165     napi_create_object(commonEventDataWorkerData->env, &result);
166     if (SetCommonEventData(commonEventDataWorkerData, result) == nullptr) {
167         napi_close_handle_scope(commonEventDataWorkerData->env, scope);
168         delete commonEventDataWorkerData;
169         commonEventDataWorkerData = nullptr;
170         return;
171     }
172 
173     napi_value undefined = nullptr;
174     napi_get_undefined(commonEventDataWorkerData->env, &undefined);
175 
176     napi_value callback = nullptr;
177     napi_value resultout = nullptr;
178     napi_get_reference_value(commonEventDataWorkerData->env, commonEventDataWorkerData->ref, &callback);
179 
180     napi_value results[ARGS_TWO_EVENT] = {nullptr};
181     results[INDEX_ZERO] = GetCallbackErrorValue(commonEventDataWorkerData->env, NO_ERROR);
182     results[INDEX_ONE] = result;
183     napi_call_function(
184         commonEventDataWorkerData->env, undefined, callback, ARGS_TWO_EVENT, &results[INDEX_ZERO], &resultout);
185 
186     napi_close_handle_scope(commonEventDataWorkerData->env, scope);
187     delete commonEventDataWorkerData;
188     commonEventDataWorkerData = nullptr;
189 }
190 
SubscriberInstance(const CommonEventSubscribeInfo & sp)191 SubscriberInstance::SubscriberInstance(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp)
192 {
193     id_ = ++subscriberID_;
194     EVENT_LOGD("Create SubscriberInstance[%{public}llu]", id_.load());
195     valid_ = std::make_shared<bool>(false);
196 }
197 
~SubscriberInstance()198 SubscriberInstance::~SubscriberInstance()
199 {
200     EVENT_LOGD("destroy SubscriberInstance[%{public}llu]", id_.load());
201     *valid_ = false;
202     std::lock_guard<std::mutex> lock(envMutex_);
203     if (env_ != nullptr && tsfn_ != nullptr) {
204         EVENT_LOGD("Release threadsafe function");
205         napi_release_threadsafe_function(tsfn_, napi_tsfn_release);
206     }
207 }
208 
GetID()209 unsigned long long SubscriberInstance::GetID()
210 {
211     return id_.load();
212 }
213 
SetEnv(const napi_env & env)214 void SubscriberInstance::SetEnv(const napi_env &env)
215 {
216     EVENT_LOGD("Enter");
217     env_ = env;
218 }
219 
GetEnv()220 napi_env SubscriberInstance::GetEnv()
221 {
222     std::lock_guard<std::mutex> lock(envMutex_);
223     return env_;
224 }
225 
ClearEnv()226 void SubscriberInstance::ClearEnv()
227 {
228     EVENT_LOGD("Env expired, clear SubscriberInstance env");
229     std::lock_guard<std::mutex> lock(envMutex_);
230     env_ = nullptr;
231     tsfn_ = nullptr;
232 }
233 
SetCallbackRef(const napi_ref & ref)234 void SubscriberInstance::SetCallbackRef(const napi_ref &ref)
235 {
236     ref_ = ref;
237     *valid_ = ref_ != nullptr ? true : false;
238 }
239 
SetThreadSafeFunction(const napi_threadsafe_function & tsfn)240 void SubscriberInstance::SetThreadSafeFunction(const napi_threadsafe_function &tsfn)
241 {
242     tsfn_ = tsfn;
243 }
244 
OnReceiveEvent(const CommonEventData & data)245 void SubscriberInstance::OnReceiveEvent(const CommonEventData &data)
246 {
247     EVENT_LOGD("OnReceiveEvent excute");
248     CommonEventDataWorker *commonEventDataWorker = new (std::nothrow) CommonEventDataWorker();
249     if (commonEventDataWorker == nullptr) {
250         EVENT_LOGE("Invalid commonEventDataWorker");
251         return;
252     }
253     commonEventDataWorker->want = data.GetWant();
254     EVENT_LOGD("OnReceiveEvent() action = %{public}s", data.GetWant().GetAction().c_str());
255     commonEventDataWorker->code = data.GetCode();
256     commonEventDataWorker->data = data.GetData();
257     commonEventDataWorker->ref = ref_;
258     commonEventDataWorker->valid = valid_;
259 
260     if (this->IsOrderedCommonEvent()) {
261         std::lock_guard<std::mutex> lock(subscriberInsMutex);
262         for (auto subscriberInstance : subscriberInstances) {
263             if (subscriberInstance.first.get() == this) {
264                 subscriberInstances[subscriberInstance.first].commonEventResult = GoAsyncCommonEvent();
265                 break;
266             }
267         }
268     }
269     std::lock_guard<std::mutex> lock(envMutex_);
270     commonEventDataWorker->env = env_;
271     if (env_ != nullptr && tsfn_ != nullptr) {
272         napi_acquire_threadsafe_function(tsfn_);
273         napi_call_threadsafe_function(tsfn_, commonEventDataWorker, napi_tsfn_nonblocking);
274         napi_release_threadsafe_function(tsfn_, napi_tsfn_release);
275         EVENT_LOGD("OnReceiveEvent complete");
276     }
277 
278     if (commonEventDataWorker != nullptr) {
279         EVENT_LOGD("commonEventDataWorker is using");
280     }
281 }
282 
283 void ThreadFinished(napi_env env, void* data, [[maybe_unused]] void* context)
284 {
285     EVENT_LOGD("ThreadFinished");
286 }
287 
CreateSubscriber(napi_env env,napi_callback_info info)288 napi_value CreateSubscriber(napi_env env, napi_callback_info info)
289 {
290     EVENT_LOGD("CreateSubscriber excute");
291 
292     size_t argc = CREATE_MAX_PARA;
293     napi_value argv[CREATE_MAX_PARA] = {nullptr};
294     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
295     if (argc < 1) {
296         EVENT_LOGE("Wrong number of parameters");
297         return NapiGetNull(env);
298     }
299 
300     napi_ref callback = nullptr;
301     if (ParseParametersByCreateSubscriber(env, argv, argc, callback) == nullptr) {
302         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
303         return NapiGetNull(env);
304     }
305 
306     AsyncCallbackInfoCreate *asyncCallbackInfo =
307         new (std::nothrow) AsyncCallbackInfoCreate {.env = env, .asyncWork = nullptr, .subscribeInfo = nullptr};
308     if (asyncCallbackInfo == nullptr) {
309         EVENT_LOGE("asyncCallbackInfo is null");
310         return NapiGetNull(env);
311     }
312     napi_value promise = nullptr;
313 
314     PaddingAsyncCallbackInfoCreateSubscriber(env, asyncCallbackInfo, callback, promise);
315 
316     napi_create_reference(env, argv[0], 1, &asyncCallbackInfo->subscribeInfo);
317 
318     napi_value resourceName = nullptr;
319     napi_create_string_latin1(env, "CreateSubscriber", NAPI_AUTO_LENGTH, &resourceName);
320 
321     // Asynchronous function call
322     napi_create_async_work(env,
323         nullptr,
324         resourceName,
325         [](napi_env env, void *data) { EVENT_LOGD("CreateSubscriber napi_create_async_work start"); },
326         [](napi_env env, napi_status status, void *data) {
327             EVENT_LOGD("CreateSubscriber napi_create_async_work end");
328             AsyncCallbackInfoCreate *asyncCallbackInfo = static_cast<AsyncCallbackInfoCreate *>(data);
329             if (asyncCallbackInfo) {
330                 napi_value constructor = nullptr;
331                 napi_value subscribeInfoRefValue = nullptr;
332                 napi_get_reference_value(env, asyncCallbackInfo->subscribeInfo, &subscribeInfoRefValue);
333                 napi_get_reference_value(env, g_CommonEventSubscriber, &constructor);
334                 napi_new_instance(env, constructor, 1, &subscribeInfoRefValue, &asyncCallbackInfo->result);
335 
336                 if (asyncCallbackInfo->result == nullptr) {
337                     EVENT_LOGE("create subscriber instance failed");
338                     asyncCallbackInfo->info.errorCode = ERR_CES_FAILED;
339                 }
340                 ReturnCallbackPromise(env, asyncCallbackInfo->info, asyncCallbackInfo->result);
341                 if (asyncCallbackInfo->info.callback != nullptr) {
342                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
343                 }
344                 if (asyncCallbackInfo->subscribeInfo != nullptr) {
345                     napi_delete_reference(env, asyncCallbackInfo->subscribeInfo);
346                 }
347                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
348                 delete asyncCallbackInfo;
349                 asyncCallbackInfo = nullptr;
350             }
351             EVENT_LOGD("CreateSubscriber work complete end");
352         },
353         (void *)asyncCallbackInfo,
354         &asyncCallbackInfo->asyncWork);
355 
356     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
357 
358     if (asyncCallbackInfo->info.isCallback) {
359         EVENT_LOGD("Delete napiCreateSubscriber callback reference.");
360         return NapiGetNull(env);
361     } else {
362         return promise;
363     }
364 }
365 
CreateSubscriberSync(napi_env env,napi_callback_info info)366 napi_value CreateSubscriberSync(napi_env env, napi_callback_info info)
367 {
368     EVENT_LOGD("CreateSubscriberSync start");
369 
370     size_t argc = ARGC_ONE;
371     napi_value argv[ARGC_ONE] = {nullptr};
372     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
373     if (argc < 1) {
374         EVENT_LOGE("Wrong number of arguments");
375         return NapiGetNull(env);
376     }
377 
378     napi_valuetype valuetype;
379 
380     // argv[0]:CommonEventSubscribeInfo
381     NAPI_CALL(env, napi_typeof(env, argv[0], &valuetype));
382     if (valuetype != napi_object) {
383         EVENT_LOGE("Wrong argument type. object expected.");
384         std::string msg = "Incorrect parameter types.The type of param must be object.";
385         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID, msg);
386         return NapiGetNull(env);
387     }
388 
389     napi_ref subscribeInfo = nullptr;
390     napi_create_reference(env, argv[0], 1, &subscribeInfo);
391 
392     napi_value result = nullptr;
393     napi_value constructor = nullptr;
394     napi_value subscribeInfoRefValue = nullptr;
395     napi_get_reference_value(env, subscribeInfo, &subscribeInfoRefValue);
396     napi_get_reference_value(env, g_CommonEventSubscriber, &constructor);
397     napi_new_instance(env, constructor, 1, &subscribeInfoRefValue, &result);
398 
399     if (result == nullptr) {
400         EVENT_LOGE("create subscriber instance failed");
401         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
402         return NapiGetNull(env);
403     }
404 
405     if (subscribeInfo != nullptr) {
406         napi_delete_reference(env, subscribeInfo);
407     }
408 
409     return result;
410 }
411 
GetAsyncResult(const SubscriberInstance * objectInfo)412 std::shared_ptr<AsyncCommonEventResult> GetAsyncResult(const SubscriberInstance *objectInfo)
413 {
414     EVENT_LOGD("GetAsyncResult excute");
415     if (!objectInfo) {
416         EVENT_LOGE("Invalid objectInfo");
417         return nullptr;
418     }
419     std::lock_guard<std::mutex> lock(subscriberInsMutex);
420     for (auto subscriberInstance : subscriberInstances) {
421         if (subscriberInstance.first.get() == objectInfo) {
422             return subscriberInstance.second.commonEventResult;
423         }
424     }
425     EVENT_LOGW("Unable to found objectInfo");
426     return nullptr;
427 }
428 
GetSubscriber(const napi_env & env,const napi_value & value)429 std::shared_ptr<SubscriberInstance> GetSubscriber(const napi_env &env, const napi_value &value)
430 {
431     EVENT_LOGD("GetSubscriber excute");
432 
433     SubscriberInstanceWrapper *wrapper = nullptr;
434     napi_unwrap(env, value, (void **)&wrapper);
435     if (wrapper == nullptr) {
436         EVENT_LOGW("GetSubscriber wrapper is null");
437         return nullptr;
438     }
439 
440     return wrapper->GetSubscriber();
441 }
442 
Subscribe(napi_env env,napi_callback_info info)443 napi_value Subscribe(napi_env env, napi_callback_info info)
444 {
445     EVENT_LOGD("Subscribe excute");
446 
447     // Argument parsing
448     size_t argc = SUBSCRIBE_MAX_PARA;
449     napi_value argv[SUBSCRIBE_MAX_PARA] = {nullptr};
450     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
451     if (argc < SUBSCRIBE_MAX_PARA) {
452         EVENT_LOGE("Wrong number of arguments");
453         return NapiGetNull(env);
454     }
455 
456     napi_ref callback = nullptr;
457     std::shared_ptr<SubscriberInstance> subscriber = nullptr;
458 
459     if (ParseParametersBySubscribe(env, argv, subscriber, callback) == nullptr) {
460         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
461         return NapiGetNull(env);
462     }
463 
464     AsyncCallbackInfoSubscribe *asyncCallbackInfo =
465         new (std::nothrow) AsyncCallbackInfoSubscribe {.env = env, .asyncWork = nullptr, .subscriber = nullptr};
466     if (asyncCallbackInfo == nullptr) {
467         EVENT_LOGE("asyncCallbackInfo is nullptr");
468         return NapiGetNull(env);
469     }
470     asyncCallbackInfo->subscriber = subscriber;
471     asyncCallbackInfo->callback = callback;
472 
473     napi_value resourceName = nullptr;
474     napi_create_string_latin1(env, "Subscribe", NAPI_AUTO_LENGTH, &resourceName);
475     napi_create_threadsafe_function(env, argv[1], nullptr, resourceName, 0, 1, asyncCallbackInfo->callback,
476         ThreadFinished, nullptr, ThreadSafeCallback, &(asyncCallbackInfo->tsfn));
477     // Calling asynchronous functions
478     napi_create_async_work(env,
479         nullptr,
480         resourceName,
481         [](napi_env env, void *data) {
482             EVENT_LOGD("Subscribe napi_create_async_work excute");
483             AsyncCallbackInfoSubscribe *asyncCallbackInfo = static_cast<AsyncCallbackInfoSubscribe *>(data);
484             if (asyncCallbackInfo) {
485                 asyncCallbackInfo->subscriber->SetEnv(env);
486                 asyncCallbackInfo->subscriber->SetCallbackRef(asyncCallbackInfo->callback);
487                 asyncCallbackInfo->subscriber->SetThreadSafeFunction(asyncCallbackInfo->tsfn);
488                 asyncCallbackInfo->errorCode = CommonEventManager::NewSubscribeCommonEvent(
489                     asyncCallbackInfo->subscriber);
490             }
491         },
492         [](napi_env env, napi_status status, void *data) {
493             EVENT_LOGD("Subscribe napi_create_async_work end");
494             AsyncCallbackInfoSubscribe *asyncCallbackInfo = static_cast<AsyncCallbackInfoSubscribe *>(data);
495             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
496             if (asyncCallbackInfo->errorCode == NO_ERROR) {
497                 EVENT_LOGD("asyncCallbackInfo is 0");
498                 std::lock_guard<std::mutex> lock(subscriberInsMutex);
499                 subscriberInstances[asyncCallbackInfo->subscriber].asyncCallbackInfo.emplace_back(asyncCallbackInfo);
500             } else {
501                 SetCallback(env, asyncCallbackInfo->callback, asyncCallbackInfo->errorCode, NapiGetNull(env));
502 
503                 if (asyncCallbackInfo->callback != nullptr) {
504                     napi_delete_reference(env, asyncCallbackInfo->callback);
505                 }
506 
507                 delete asyncCallbackInfo;
508                 asyncCallbackInfo = nullptr;
509             }
510         },
511         (void *)asyncCallbackInfo,
512         &asyncCallbackInfo->asyncWork);
513     napi_add_env_cleanup_hook(env, ClearEnvCallback, subscriber.get());
514     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
515     return NapiGetNull(env);
516 }
517 
Publish(napi_env env,napi_callback_info info)518 napi_value Publish(napi_env env, napi_callback_info info)
519 {
520     EVENT_LOGD("NapiPublish start");
521     size_t argc = PUBLISH_MAX_PARA_BY_PUBLISHDATA;
522     napi_value argv[PUBLISH_MAX_PARA_BY_PUBLISHDATA] = {nullptr};
523     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
524     if (argc < PUBLISH_MAX_PARA) {
525         EVENT_LOGE("Wrong number of arguments.");
526         return NapiGetNull(env);
527     }
528 
529     std::string event;
530     CommonEventPublishDataByjs commonEventPublishDatajs;
531     napi_ref callback = nullptr;
532 
533     if (ParseParametersByPublish(env, argv, argc, event, commonEventPublishDatajs, callback) == nullptr) {
534         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
535         return NapiGetNull(env);
536     }
537 
538     AsyncCallbackInfoPublish *asyncCallbackInfo =
539         new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
540     if (asyncCallbackInfo == nullptr) {
541         EVENT_LOGD("Create asyncCallbackInfo is fail.");
542         return NapiGetNull(env);
543     }
544     asyncCallbackInfo->callback = callback;
545 
546     // CommonEventData::want->action
547     Want want;
548     want.SetAction(event);
549     if (argc == PUBLISH_MAX_PARA_BY_PUBLISHDATA) {
550         PaddingCallbackInfoPublish(want, asyncCallbackInfo, commonEventPublishDatajs);
551     }
552     asyncCallbackInfo->commonEventData.SetWant(want);
553 
554     napi_value resourceName = nullptr;
555     napi_create_string_latin1(env, "Publish", NAPI_AUTO_LENGTH, &resourceName);
556 
557     // Calling Asynchronous functions
558     napi_create_async_work(env,
559         nullptr,
560         resourceName,
561         [](napi_env env, void *data) {
562             EVENT_LOGD("Publish napi_create_async_work excute");
563             AsyncCallbackInfoPublish *asyncCallbackInfo = static_cast<AsyncCallbackInfoPublish *>(data);
564             if (asyncCallbackInfo) {
565                 asyncCallbackInfo->errorCode = CommonEventManager::NewPublishCommonEvent(
566                     asyncCallbackInfo->commonEventData, asyncCallbackInfo->commonEventPublishInfo);
567             }
568         },
569         [](napi_env env, napi_status status, void *data) {
570             EVENT_LOGD("NapiPublish work complete.");
571             AsyncCallbackInfoPublish *asyncCallbackInfo = static_cast<AsyncCallbackInfoPublish *>(data);
572             if (asyncCallbackInfo) {
573                 SetCallback(env, asyncCallbackInfo->callback, asyncCallbackInfo->errorCode, NapiGetNull(env));
574                 if (asyncCallbackInfo->callback != nullptr) {
575                     EVENT_LOGD("Delete napiPublish callback reference.");
576                     napi_delete_reference(env, asyncCallbackInfo->callback);
577                 }
578                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
579                 delete asyncCallbackInfo;
580                 asyncCallbackInfo = nullptr;
581             }
582             EVENT_LOGD("NapiPublish work complete end.");
583         },
584         (void *)asyncCallbackInfo,
585         &asyncCallbackInfo->asyncWork);
586 
587     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
588 
589     return NapiGetNull(env);
590 }
591 
Finalizer(napi_env env,void * data,void * hint)592 void NapiStaticSubscribe::Finalizer(napi_env env, void *data, void *hint)
593 {
594     EVENT_LOGD("called");
595     delete static_cast<NapiStaticSubscribe *>(data);
596 }
597 
PublishAsUser(napi_env env,napi_callback_info info)598 napi_value PublishAsUser(napi_env env, napi_callback_info info)
599 {
600     EVENT_LOGD("Publish excute");
601 
602     size_t argc = PUBLISH_MAX_PARA_BY_USERID;
603     napi_value argv[PUBLISH_MAX_PARA_BY_USERID] = {nullptr};
604     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
605     if (argc < PUBLISH_MAX_PARA_AS_USER) {
606         EVENT_LOGE("Wrong number of Parameter.");
607         return NapiGetNull(env);
608     }
609 
610     std::string event;
611     int32_t userId = UNDEFINED_USER;
612     CommonEventPublishDataByjs commonEventPublishDatajs;
613     napi_ref callback = nullptr;
614 
615     if (ParseParametersByPublishAsUser(env, argv, argc, event, userId, commonEventPublishDatajs, callback) == nullptr) {
616         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
617         return NapiGetNull(env);
618     }
619 
620     AsyncCallbackInfoPublish *asyncCallbackInfo =
621         new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
622     if (asyncCallbackInfo == nullptr) {
623         EVENT_LOGE("asyncCallbackInfo is nullptr");
624         return NapiGetNull(env);
625     }
626     asyncCallbackInfo->callback = callback;
627 
628     // CommonEventData::want->action.
629     Want want;
630     want.SetAction(event);
631     if (argc == PUBLISH_MAX_PARA_BY_USERID) {
632         PaddingCallbackInfoPublish(want, asyncCallbackInfo, commonEventPublishDatajs);
633     }
634     asyncCallbackInfo->commonEventData.SetWant(want);
635     asyncCallbackInfo->userId = userId;
636 
637     napi_value resourceName = nullptr;
638     napi_create_string_latin1(env, "Publish", NAPI_AUTO_LENGTH, &resourceName);
639 
640     // Calling Asynchronous functions
641     napi_create_async_work(env,
642         nullptr,
643         resourceName,
644         [](napi_env env, void *data) {
645             EVENT_LOGD("Publish napi_create_async_work start");
646             AsyncCallbackInfoPublish *asyncCallbackInfo = static_cast<AsyncCallbackInfoPublish *>(data);
647             if (asyncCallbackInfo) {
648                 asyncCallbackInfo->errorCode = CommonEventManager::NewPublishCommonEventAsUser(
649                     asyncCallbackInfo->commonEventData, asyncCallbackInfo->commonEventPublishInfo,
650                     asyncCallbackInfo->userId);
651             }
652         },
653         [](napi_env env, napi_status status, void *data) {
654             EVENT_LOGD("NapiPublishAsUser work complete.");
655             AsyncCallbackInfoPublish *asyncCallbackInfo = static_cast<AsyncCallbackInfoPublish *>(data);
656             if (asyncCallbackInfo) {
657                 SetCallback(env, asyncCallbackInfo->callback, asyncCallbackInfo->errorCode, NapiGetNull(env));
658                 if (asyncCallbackInfo->callback != nullptr) {
659                     EVENT_LOGD("Delete NapiPublishAsUser callback reference.");
660                     napi_delete_reference(env, asyncCallbackInfo->callback);
661                 }
662                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
663                 delete asyncCallbackInfo;
664                 asyncCallbackInfo = nullptr;
665             }
666             EVENT_LOGD("NapiPublishAsUser work complete end.");
667         },
668         (void *)asyncCallbackInfo,
669         &asyncCallbackInfo->asyncWork);
670 
671     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
672 
673     return NapiGetNull(env);
674 }
675 
GetSubscriberByUnsubscribe(const napi_env & env,const napi_value & value,std::shared_ptr<SubscriberInstance> & subscriber,bool & isFind)676 napi_value GetSubscriberByUnsubscribe(
677     const napi_env &env, const napi_value &value, std::shared_ptr<SubscriberInstance> &subscriber, bool &isFind)
678 {
679     EVENT_LOGD("GetSubscriberByUnsubscribe excute");
680 
681     isFind = false;
682     subscriber = GetSubscriber(env, value);
683     if (subscriber == nullptr) {
684         EVENT_LOGE("subscriber is null");
685         return nullptr;
686     }
687 
688     std::lock_guard<std::mutex> lock(subscriberInsMutex);
689     for (auto subscriberInstance : subscriberInstances) {
690         if (subscriberInstance.first.get() == subscriber.get()) {
691             subscriber = subscriberInstance.first;
692             isFind = true;
693             break;
694         }
695     }
696 
697     return NapiGetNull(env);
698 }
699 
NapiDeleteSubscribe(const napi_env & env,std::shared_ptr<SubscriberInstance> & subscriber)700 void NapiDeleteSubscribe(const napi_env &env, std::shared_ptr<SubscriberInstance> &subscriber)
701 {
702     EVENT_LOGD("NapiDeleteSubscribe excute");
703     std::lock_guard<std::mutex> lock(subscriberInsMutex);
704     auto subscribe = subscriberInstances.find(subscriber);
705     if (subscribe != subscriberInstances.end()) {
706         for (auto asyncCallbackInfoSubscribe : subscribe->second.asyncCallbackInfo) {
707             if (asyncCallbackInfoSubscribe->callback != nullptr) {
708                 napi_delete_reference(env, asyncCallbackInfoSubscribe->callback);
709             }
710             delete asyncCallbackInfoSubscribe;
711             asyncCallbackInfoSubscribe = nullptr;
712             EVENT_LOGD("asyncCallbackInfoSubscribe is null");
713         }
714         subscriber->SetCallbackRef(nullptr);
715         napi_remove_env_cleanup_hook(subscriber->GetEnv(), ClearEnvCallback, subscriber.get());
716         subscriberInstances.erase(subscribe);
717     }
718 }
719 
Unsubscribe(napi_env env,napi_callback_info info)720 napi_value Unsubscribe(napi_env env, napi_callback_info info)
721 {
722     EVENT_LOGD("Unsubscribe excute");
723 
724     // Argument parsing
725     size_t argc = UNSUBSCRIBE_MAX_PARA;
726     napi_value argv[UNSUBSCRIBE_MAX_PARA] = {nullptr};
727     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
728     if (argc < 1) {
729         EVENT_LOGE("Wrong number of parameters");
730         return NapiGetNull(env);
731     }
732 
733     napi_ref callback = nullptr;
734     std::shared_ptr<SubscriberInstance> subscriber = nullptr;
735     napi_value result = nullptr;
736     result = ParseParametersByUnsubscribe(env, argc, argv, subscriber, callback);
737     if (result == nullptr) {
738         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
739         return NapiGetNull(env);
740     }
741     bool isFind = false;
742     napi_get_value_bool(env, result, &isFind);
743     if (!isFind) {
744         EVENT_LOGE("Unsubscribe failed. The current subscriber does not exist.");
745         return NapiGetNull(env);
746     }
747 
748     AsyncCallbackInfoUnsubscribe *asynccallback = new (std::nothrow) AsyncCallbackInfoUnsubscribe();
749     if (asynccallback == nullptr) {
750         EVENT_LOGE("asynccallback is nullptr");
751         return NapiGetNull(env);
752     }
753     asynccallback->env = env;
754     asynccallback->subscriber = subscriber;
755     asynccallback->argc = argc;
756     if (argc >= UNSUBSCRIBE_MAX_PARA) {
757         asynccallback->callback = callback;
758     }
759 
760     napi_value resourceName = nullptr;
761     napi_create_string_latin1(env, "Unsubscribe", NAPI_AUTO_LENGTH, &resourceName);
762 
763     // Calling Asynchronous functions
764     napi_create_async_work(env,
765         nullptr,
766         resourceName,
767         [](napi_env env, void *data) {
768             EVENT_LOGD("Unsubscribe napi_create_async_work start");
769             AsyncCallbackInfoUnsubscribe *asyncCallbackInfo = static_cast<AsyncCallbackInfoUnsubscribe *>(data);
770             if (asyncCallbackInfo) {
771                 asyncCallbackInfo->errorCode = CommonEventManager::NewUnSubscribeCommonEvent(
772                     asyncCallbackInfo->subscriber);
773             }
774         },
775         [](napi_env env, napi_status status, void *data) {
776             EVENT_LOGD("Unsubscribe napi_create_async_work complete");
777             AsyncCallbackInfoUnsubscribe *asyncCallbackInfo = static_cast<AsyncCallbackInfoUnsubscribe *>(data);
778             if (asyncCallbackInfo) {
779                 if (asyncCallbackInfo->argc >= UNSUBSCRIBE_MAX_PARA) {
780                     napi_value result = nullptr;
781                     napi_get_null(env, &result);
782                     SetCallback(env, asyncCallbackInfo->callback, asyncCallbackInfo->errorCode, result);
783                 }
784                 if (asyncCallbackInfo->callback != nullptr) {
785                     EVENT_LOGD("Delete cancel callback reference.");
786                     napi_delete_reference(env, asyncCallbackInfo->callback);
787                 }
788                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
789                 NapiDeleteSubscribe(env, asyncCallbackInfo->subscriber);
790                 delete asyncCallbackInfo;
791                 asyncCallbackInfo = nullptr;
792             }
793         },
794         (void *)asynccallback,
795         &asynccallback->asyncWork);
796 
797     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asynccallback->asyncWork, napi_qos_user_initiated));
798     return NapiGetNull(env);
799 }
800 
RemoveStickyCommonEvent(napi_env env,napi_callback_info info)801 napi_value RemoveStickyCommonEvent(napi_env env, napi_callback_info info)
802 {
803     EVENT_LOGD("RemoveStickyCommonEvent start");
804 
805     std::string event;
806     CallbackPromiseInfo params;
807     napi_value result = ParseParametersByRemoveSticky(env, info, event, params);
808     if (result == nullptr) {
809         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
810         return NapiGetNull(env);
811     }
812 
813     AsyncCallbackRemoveSticky *asyncCallbackInfo =
814         new (std::nothrow) AsyncCallbackRemoveSticky {.env = env, .asyncWork = nullptr, .event = event};
815     if (asyncCallbackInfo == nullptr) {
816         EVENT_LOGE("asyncCallbackInfo is null");
817         return NapiGetNull(env);
818     }
819     napi_value promise = nullptr;
820     PaddingCallbackPromiseInfo(env, params.callback, asyncCallbackInfo->info, promise);
821 
822     napi_value resourceName = nullptr;
823     napi_create_string_latin1(env, "removeStickyCommonEvent", NAPI_AUTO_LENGTH, &resourceName);
824 
825     // Asynchronous function call
826     napi_create_async_work(env,
827         nullptr,
828         resourceName,
829         [](napi_env env, void *data) {
830             EVENT_LOGD("removeStickyCommonEvent napi_create_async_work start");
831             AsyncCallbackRemoveSticky *asyncCallbackInfo = static_cast<AsyncCallbackRemoveSticky *>(data);
832             if (asyncCallbackInfo) {
833                 asyncCallbackInfo->info.errorCode =
834                     CommonEventManager::RemoveStickyCommonEvent(asyncCallbackInfo->event);
835             }
836         },
837         AsyncCompleteCallbackRemoveStickyCommonEvent,
838         (void *)asyncCallbackInfo,
839         &asyncCallbackInfo->asyncWork);
840 
841     napi_status status = napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
842     if (status != napi_ok) {
843         delete asyncCallbackInfo;
844         asyncCallbackInfo = nullptr;
845         EVENT_LOGE("napi_queue_async_work failed return: %{public}d", status);
846         return NapiGetNull(env);
847     }
848 
849     if (asyncCallbackInfo->info.isCallback) {
850         return NapiGetNull(env);
851     } else {
852         return promise;
853     }
854 }
855 
CommonEventSubscriberConstructor(napi_env env,napi_callback_info info)856 napi_value CommonEventSubscriberConstructor(napi_env env, napi_callback_info info)
857 {
858     EVENT_LOGD("enter");
859     napi_value thisVar = nullptr;
860     CommonEventSubscribeInfo subscribeInfo;
861     if (!ParseParametersConstructor(env, info, thisVar, subscribeInfo)) {
862         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
863         return NapiGetNull(env);
864     }
865     subscribeInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::ThreadMode::HANDLER);
866     auto wrapper = new (std::nothrow) SubscriberInstanceWrapper(subscribeInfo);
867     if (wrapper == nullptr) {
868         EVENT_LOGE("wrapper is null");
869         return NapiGetNull(env);
870     }
871 
872     napi_wrap(env, thisVar, wrapper,
873         [](napi_env env, void *data, void *hint) {
874             auto *wrapper = reinterpret_cast<SubscriberInstanceWrapper *>(data);
875             EVENT_LOGD("Constructor destroy");
876             std::lock_guard<std::mutex> lock(subscriberInsMutex);
877             for (auto subscriberInstance : subscriberInstances) {
878                 if (subscriberInstance.first.get() == wrapper->GetSubscriber().get()) {
879                     for (auto asyncCallbackInfo : subscriberInstance.second.asyncCallbackInfo) {
880                         if (asyncCallbackInfo->callback != nullptr) {
881                             napi_delete_reference(env, asyncCallbackInfo->callback);
882                         }
883                         delete asyncCallbackInfo;
884                         asyncCallbackInfo = nullptr;
885                     }
886                     wrapper->GetSubscriber()->SetCallbackRef(nullptr);
887                     CommonEventManager::UnSubscribeCommonEvent(subscriberInstance.first);
888                     napi_remove_env_cleanup_hook(subscriberInstance.first->GetEnv(), ClearEnvCallback,
889                         subscriberInstance.first.get());
890                     subscriberInstances.erase(subscriberInstance.first);
891                     break;
892                 }
893             }
894             delete wrapper;
895             wrapper = nullptr;
896         },
897         nullptr,
898         nullptr);
899 
900     EVENT_LOGD("end");
901     return thisVar;
902 }
903 
SetNapiResult(const napi_env & env,const CommonEventSubscribeInfo & subscribeInfo,napi_value & result)904 void SetNapiResult(const napi_env &env, const CommonEventSubscribeInfo &subscribeInfo, napi_value &result)
905 {
906     EVENT_LOGD("SetNapiResult start");
907 
908     SetEventsResult(env, subscribeInfo.GetMatchingSkills().GetEvents(), result);
909     SetPublisherPermissionResult(env, subscribeInfo.GetPermission(), result);
910     SetPublisherDeviceIdResult(env, subscribeInfo.GetDeviceId(), result);
911     SetPublisherUserIdResult(env, subscribeInfo.GetUserId(), result);
912     SetPublisherPriorityResult(env, subscribeInfo.GetPriority(), result);
913     SetPublisherBundleNameResult(env, subscribeInfo.GetPublisherBundleName(), result);
914 }
915 
GetSubscribeInfoSync(napi_env env,napi_callback_info info)916 napi_value GetSubscribeInfoSync(napi_env env, napi_callback_info info)
917 {
918     EVENT_LOGD("GetSubscribeInfoSync start");
919 
920     size_t argc = 1;
921     napi_value thisVar = nullptr;
922     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
923 
924     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
925     if (subscriber == nullptr) {
926         EVENT_LOGE("subscriber is nullptr");
927         return NapiGetNull(env);
928     }
929 
930     napi_value res = nullptr;
931     napi_create_object(env, &res);
932     SetNapiResult(env, subscriber->GetSubscribeInfo(), res);
933 
934     return res;
935 }
936 
IsOrderedCommonEventSync(napi_env env,napi_callback_info info)937 napi_value IsOrderedCommonEventSync(napi_env env, napi_callback_info info)
938 {
939     EVENT_LOGD("isOrderedCommonEventSync start");
940 
941     size_t argc = 0;
942     napi_value thisVar = nullptr;
943     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
944 
945     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
946     if (subscriber == nullptr) {
947         EVENT_LOGE("subscriber is nullptr");
948         return NapiGetNull(env);
949     }
950     bool isOrdered = false;
951 
952     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
953     if (asyncResult) {
954         isOrdered = asyncResult->IsOrderedCommonEvent();
955     } else {
956         isOrdered = subscriber->IsOrderedCommonEvent();
957     }
958 
959     napi_value result = nullptr;
960     napi_get_boolean(env, isOrdered, &result);
961 
962     return result;
963 }
964 
GetCodeSync(napi_env env,napi_callback_info info)965 napi_value GetCodeSync(napi_env env, napi_callback_info info)
966 {
967     EVENT_LOGD("getCodeSync start");
968     size_t argc = 1;
969     napi_value thisVar = nullptr;
970     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
971 
972     int32_t code = 0;
973 
974     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
975     if (subscriber == nullptr) {
976         EVENT_LOGE("subscriber is nullptr");
977         return NapiGetNull(env);
978     }
979 
980     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
981     if (asyncResult) {
982         EVENT_LOGD("get asyncResult success");
983         code = asyncResult->GetCode();
984     } else {
985         EVENT_LOGD("get asyncResult failed");
986         code = 0;
987     }
988     napi_value res = nullptr;
989     napi_create_int32(env, code, &res);
990     return res;
991 }
992 
SetCodeSync(napi_env env,napi_callback_info info)993 napi_value SetCodeSync(napi_env env, napi_callback_info info)
994 {
995     EVENT_LOGD("setCodeSync start");
996     size_t argc = ARGC_ONE;
997     napi_value argv[ARGC_ONE] = {nullptr};
998     napi_value thisVar = nullptr;
999     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1000 
1001     int32_t code = 0;
1002     NAPI_CALL(env, napi_get_value_int32(env, argv[0], &code));
1003 
1004     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1005     if (subscriber == nullptr) {
1006         EVENT_LOGE("subscriber is nullptr");
1007         return NapiGetNull(env);
1008     }
1009 
1010     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1011     if (asyncResult) {
1012         asyncResult->SetCode(code);
1013     } else {
1014         EVENT_LOGE("asyncResult is nullptr");
1015     }
1016 
1017     return NapiGetNull(env);
1018 }
1019 
GetDataSync(napi_env env,napi_callback_info info)1020 napi_value GetDataSync(napi_env env, napi_callback_info info)
1021 {
1022     EVENT_LOGD("getDataSync start");
1023     size_t argc = 1;
1024     napi_value thisVar = nullptr;
1025     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
1026 
1027     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1028     if (subscriber == nullptr) {
1029         EVENT_LOGE("subscriber is nullptr");
1030         return NapiGetNull(env);
1031     }
1032 
1033     std::string data;
1034 
1035     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1036     if (asyncResult) {
1037         data = asyncResult->GetData();
1038     } else {
1039         data = std::string();
1040     }
1041     napi_value res = nullptr;
1042     napi_create_string_utf8(env, data.c_str(), NAPI_AUTO_LENGTH, &res);
1043     return res;
1044 }
1045 
SetDataSync(napi_env env,napi_callback_info info)1046 napi_value SetDataSync(napi_env env, napi_callback_info info)
1047 {
1048     EVENT_LOGD("setDataSync start");
1049     size_t argc = ARGC_ONE;
1050     napi_value argv[ARGC_ONE] = {nullptr};
1051     napi_value thisVar = nullptr;
1052     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1053 
1054     char str[STR_DATA_MAX_SIZE] = {0};
1055     size_t strLen = 0;
1056     std::string data;
1057     NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], str, STR_DATA_MAX_SIZE, &strLen));
1058     if (strLen > STR_DATA_MAX_SIZE - 1) {
1059         EVENT_LOGE("data over size");
1060         return NapiGetNull(env);
1061     }
1062     data = str;
1063 
1064     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1065     if (subscriber == nullptr) {
1066         EVENT_LOGE("subscriber is nullptr");
1067         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1068         return NapiGetNull(env);
1069     }
1070 
1071     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1072     if (asyncResult) {
1073         asyncResult->SetData(data);
1074     }
1075 
1076     return NapiGetNull(env);
1077 }
1078 
SetCodeAndDataSync(napi_env env,napi_callback_info info)1079 napi_value SetCodeAndDataSync(napi_env env, napi_callback_info info)
1080 {
1081     EVENT_LOGD("setCodeAndDataSync start");
1082     size_t argc = ARGC_TWO;
1083     napi_value argv[ARGC_TWO] = {nullptr};
1084     napi_value thisVar = nullptr;
1085     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1086 
1087     int32_t code = 0;
1088     NAPI_CALL(env, napi_get_value_int32(env, argv[0], &code));
1089 
1090     char str[STR_DATA_MAX_SIZE] = {0};
1091     size_t strLen = 0;
1092     std::string data;
1093     NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], str, STR_DATA_MAX_SIZE, &strLen));
1094     if (strLen > STR_DATA_MAX_SIZE - 1) {
1095         EVENT_LOGE("data over size");
1096         std::string msg = "Parameter verification failed. cannot exceed ";
1097         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID,
1098             msg.append(std::to_string(STR_DATA_MAX_SIZE - 1)).append(" characters"));
1099         return NapiGetNull(env);
1100     }
1101     data = str;
1102 
1103     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1104     if (subscriber == nullptr) {
1105         EVENT_LOGE("subscriber is nullptr");
1106         return NapiGetNull(env);
1107     }
1108 
1109     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1110     if (asyncResult) {
1111         asyncResult->SetCodeAndData(code, data);
1112     }
1113     return NapiGetNull(env);
1114 }
1115 
AbortCommonEventSync(napi_env env,napi_callback_info info)1116 napi_value AbortCommonEventSync(napi_env env, napi_callback_info info)
1117 {
1118     EVENT_LOGD("abortCommonEventSync start");
1119     size_t argc = 0;
1120     napi_value thisVar = nullptr;
1121     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
1122 
1123     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1124     if (subscriber == nullptr) {
1125         EVENT_LOGE("subscriber is nullptr");
1126         return NapiGetNull(env);
1127     }
1128 
1129     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1130     if (asyncResult) {
1131         asyncResult->AbortCommonEvent();
1132     }
1133 
1134     return NapiGetNull(env);
1135 }
1136 
ClearAbortCommonEventSync(napi_env env,napi_callback_info info)1137 napi_value ClearAbortCommonEventSync(napi_env env, napi_callback_info info)
1138 {
1139     EVENT_LOGD("clearAbortCommonEventSync start");
1140     size_t argc = 1;
1141     napi_value thisVar = nullptr;
1142     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
1143 
1144     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1145 
1146     if (subscriber == nullptr) {
1147         EVENT_LOGE("subscriber is nullptr");
1148         return NapiGetNull(env);
1149     }
1150 
1151     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1152     if (asyncResult) {
1153         asyncResult->ClearAbortCommonEvent();
1154     }
1155 
1156     return NapiGetNull(env);
1157 }
1158 
GetAbortCommonEventSync(napi_env env,napi_callback_info info)1159 napi_value GetAbortCommonEventSync(napi_env env, napi_callback_info info)
1160 {
1161     EVENT_LOGD("GetAbortCommonEventSync start");
1162     size_t argc = 1;
1163 
1164     napi_value thisVar = nullptr;
1165     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
1166 
1167     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1168     if (subscriber == nullptr) {
1169         EVENT_LOGE("subscriber is nullptr");
1170         return NapiGetNull(env);
1171     }
1172 
1173     bool abortEvent = false;
1174 
1175     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1176     if (asyncResult) {
1177         abortEvent = asyncResult->GetAbortCommonEvent();
1178     } else {
1179         abortEvent = false;
1180     }
1181 
1182     napi_value result = nullptr;
1183     napi_get_boolean(env, abortEvent, &result);
1184 
1185     return result;
1186 }
1187 
IsStickyCommonEventSync(napi_env env,napi_callback_info info)1188 napi_value IsStickyCommonEventSync(napi_env env, napi_callback_info info)
1189 {
1190     EVENT_LOGD("isStickyCommonEventSync start");
1191 
1192     size_t argc = 0;
1193     napi_value thisVar = nullptr;
1194     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, NULL));
1195 
1196     std::shared_ptr<SubscriberInstance> subscriber = GetSubscriber(env, thisVar);
1197     if (subscriber == nullptr) {
1198         EVENT_LOGE("subscriber is nullptr");
1199         return NapiGetNull(env);
1200     }
1201 
1202     bool isSticky = false;
1203 
1204     std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(subscriber.get());
1205     if (asyncResult) {
1206         isSticky = asyncResult->IsStickyCommonEvent();
1207     } else {
1208         isSticky = subscriber->IsStickyCommonEvent();
1209     }
1210 
1211     napi_value result = nullptr;
1212     napi_get_boolean(env, isSticky, &result);
1213 
1214     return result;
1215 }
1216 
GetSubscribeInfo(napi_env env,napi_callback_info info)1217 napi_value GetSubscribeInfo(napi_env env, napi_callback_info info)
1218 {
1219     EVENT_LOGD("GetSubscribeInfo excute");
1220 
1221     size_t argc = 1;
1222     napi_value argv[1] = {nullptr};
1223     napi_value thisVar = nullptr;
1224     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1225 
1226     napi_ref callback = nullptr;
1227     if (ParseParametersByGetSubscribeInfo(env, argc, argv, callback) == nullptr) {
1228         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1229         return NapiGetNull(env);
1230     }
1231 
1232     AsyncCallbackInfoSubscribeInfo *asyncCallbackInfo =
1233         new (std::nothrow) AsyncCallbackInfoSubscribeInfo {.env = env, .asyncWork = nullptr};
1234     if (asyncCallbackInfo == nullptr) {
1235         EVENT_LOGE("asyncCallbackInfo failed");
1236         return NapiGetNull(env);
1237     }
1238 
1239     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1240     if (asyncCallbackInfo->subscriber == nullptr) {
1241         EVENT_LOGE("subscriber is null");
1242         delete asyncCallbackInfo;
1243         return NapiGetNull(env);
1244     }
1245 
1246     napi_value promise = nullptr;
1247     PaddingAsyncCallbackInfoGetSubscribeInfo(env, argc, asyncCallbackInfo, callback, promise);
1248 
1249     napi_value resourceName = nullptr;
1250     napi_create_string_latin1(env, "getSubscribeInfo", NAPI_AUTO_LENGTH, &resourceName);
1251     // napi Asynchronous function call
1252     napi_create_async_work(env,
1253         nullptr,
1254         resourceName,
1255         [](napi_env env, void *data) {
1256             EVENT_LOGD("GetSubscribeInfo napi_create_async_work excute");
1257             AsyncCallbackInfoSubscribeInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfoSubscribeInfo *>(data);
1258 
1259             PaddingNapiCreateAsyncWorkCallbackInfo(asyncCallbackInfo);
1260         },
1261         [](napi_env env, napi_status status, void *data) {
1262             EVENT_LOGD("GetSubscribeInfo napi_create_async_work complete");
1263             AsyncCallbackInfoSubscribeInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfoSubscribeInfo *>(data);
1264             if (asyncCallbackInfo) {
1265                 napi_value result = nullptr;
1266                 napi_create_object(env, &result);
1267                 SetNapiResult(env, asyncCallbackInfo, result);
1268                 ReturnCallbackPromise(env, asyncCallbackInfo->info, result);
1269                 if (asyncCallbackInfo->info.callback != nullptr) {
1270                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1271                     EVENT_LOGD("Delete napiGetSubscribeInfo callback reference.");
1272                 }
1273                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1274                 delete asyncCallbackInfo;
1275                 asyncCallbackInfo = nullptr;
1276             }
1277             EVENT_LOGD("NapiGetSubscribeInfo work complete end.");
1278         },
1279         (void *)asyncCallbackInfo,
1280         &asyncCallbackInfo->asyncWork);
1281 
1282     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1283 
1284     if (asyncCallbackInfo->info.isCallback) {
1285         EVENT_LOGD("Delete napiGetSubscribeInfo callback reference.");
1286         return NapiGetNull(env);
1287     } else {
1288         return promise;
1289     }
1290 }
1291 
IsOrderedCommonEvent(napi_env env,napi_callback_info info)1292 napi_value IsOrderedCommonEvent(napi_env env, napi_callback_info info)
1293 {
1294     EVENT_LOGD("IsOrderedCommonEvent excute");
1295 
1296     size_t argc = 1;
1297     napi_value argv[1] = {nullptr};
1298     napi_value thisVar = nullptr;
1299     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1300     napi_ref callback = nullptr;
1301     if (ParseParametersByIsOrderedCommonEvent(env, argv, argc, callback) == nullptr) {
1302         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1303         return NapiGetNull(env);
1304     }
1305 
1306     AsyncCallbackInfoOrderedCommonEvent *asyncCallbackInfo = new (std::nothrow)
1307         AsyncCallbackInfoOrderedCommonEvent {.env = env, .asyncWork = nullptr};
1308     if (asyncCallbackInfo == nullptr) {
1309         EVENT_LOGD("asyncCallbackInfo failed");
1310         return NapiGetNull(env);
1311     }
1312 
1313     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1314     if (asyncCallbackInfo->subscriber == nullptr) {
1315         EVENT_LOGE("subscriber is null");
1316         delete asyncCallbackInfo;
1317         return NapiGetNull(env);
1318     }
1319 
1320     napi_value promise = nullptr;
1321     PaddingAsyncCallbackInfoIsOrderedCommonEvent(env, argc, asyncCallbackInfo, callback, promise);
1322 
1323     napi_value resourceName = nullptr;
1324     napi_create_string_latin1(env, "isOrderedCommonEvent", NAPI_AUTO_LENGTH, &resourceName);
1325     // Calling Asynchronous functions
1326     napi_create_async_work(env,
1327         nullptr,
1328         resourceName,
1329         [](napi_env env, void *data) {
1330             EVENT_LOGD("IsOrderedCommonEvent napi_create_async_work start");
1331             AsyncCallbackInfoOrderedCommonEvent *asyncCallbackInfo =
1332                 static_cast<AsyncCallbackInfoOrderedCommonEvent *>(data);
1333             if (asyncCallbackInfo) {
1334                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1335                     asyncCallbackInfo->subscriber.get());
1336                 if (asyncResult) {
1337                     asyncCallbackInfo->isOrdered = asyncResult->IsOrderedCommonEvent();
1338                 } else {
1339                     asyncCallbackInfo->isOrdered = asyncCallbackInfo->subscriber->IsOrderedCommonEvent();
1340                 }
1341             }
1342         },
1343         [](napi_env env, napi_status status, void *data) {
1344             EVENT_LOGD("IsOrderedCommonEvent napi_create_async_work end");
1345             AsyncCallbackInfoOrderedCommonEvent *asyncCallbackInfo =
1346                 static_cast<AsyncCallbackInfoOrderedCommonEvent *>(data);
1347             if (asyncCallbackInfo) {
1348                 napi_value result = nullptr;
1349                 napi_get_boolean(env, asyncCallbackInfo->isOrdered, &result);
1350                 ReturnCallbackPromise(env, asyncCallbackInfo->info, result);
1351                 if (asyncCallbackInfo->info.callback != nullptr) {
1352                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1353                     EVENT_LOGD("Delete napiIsOrderedCommonEvent callback reference.");
1354                 }
1355                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1356                 delete asyncCallbackInfo;
1357                 asyncCallbackInfo = nullptr;
1358             }
1359             EVENT_LOGD("NapiIsOrderedCommonEvent work complete end.");
1360         },
1361         (void *)asyncCallbackInfo,
1362         &asyncCallbackInfo->asyncWork);
1363 
1364     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1365 
1366     if (asyncCallbackInfo->info.isCallback) {
1367         EVENT_LOGD("Delete napiIsOrderedCommonEvent callback reference.");
1368         return NapiGetNull(env);
1369     } else {
1370         return promise;
1371     }
1372 }
1373 
IsStickyCommonEvent(napi_env env,napi_callback_info info)1374 napi_value IsStickyCommonEvent(napi_env env, napi_callback_info info)
1375 {
1376     EVENT_LOGD("IsStickyCommonEvent excute");
1377 
1378     size_t argc = 1;
1379     napi_value argv[1] = {nullptr};
1380     napi_value thisVar = nullptr;
1381     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1382 
1383     napi_ref callback = nullptr;
1384     if (ParseParametersByIsStickyCommonEvent(env, argv, argc, callback) == nullptr) {
1385         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1386         return NapiGetNull(env);
1387     }
1388 
1389     AsyncCallbackInfoStickyCommonEvent *asyncCallbackInfo = new (std::nothrow)
1390         AsyncCallbackInfoStickyCommonEvent {.env = env, .asyncWork = nullptr};
1391     if (asyncCallbackInfo == nullptr) {
1392         EVENT_LOGE("Failed to create asyncCallbackInfo.");
1393         return NapiGetNull(env);
1394     }
1395 
1396     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1397     if (asyncCallbackInfo->subscriber == nullptr) {
1398         EVENT_LOGE("subscriber is null");
1399         delete asyncCallbackInfo;
1400         return NapiGetNull(env);
1401     }
1402 
1403     napi_value promise = nullptr;
1404     PaddingAsyncCallbackInfoIsStickyCommonEvent(env, argc, asyncCallbackInfo, callback, promise);
1405 
1406     napi_value resourceName = nullptr;
1407     napi_create_string_latin1(env, "isStickyCommonEvent", NAPI_AUTO_LENGTH, &resourceName);
1408     // Calling Asynchronous functions
1409     napi_create_async_work(env,
1410         nullptr,
1411         resourceName,
1412         [](napi_env env, void *data) {
1413             EVENT_LOGD("isStickyCommonEvent napi_create_async_work excute");
1414             AsyncCallbackInfoStickyCommonEvent *asyncCallbackInfo =
1415                 static_cast<AsyncCallbackInfoStickyCommonEvent *>(data);
1416             if (asyncCallbackInfo) {
1417                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1418                     asyncCallbackInfo->subscriber.get());
1419                 if (asyncResult) {
1420                     asyncCallbackInfo->isSticky = asyncResult->IsStickyCommonEvent();
1421                 } else {
1422                     asyncCallbackInfo->isSticky = asyncCallbackInfo->subscriber->IsStickyCommonEvent();
1423                 }
1424             }
1425         },
1426         [](napi_env env, napi_status status, void *data) {
1427             EVENT_LOGD("isStickyCommonEvent napi_create_async_work end");
1428             AsyncCallbackInfoStickyCommonEvent *asyncCallbackInfo =
1429                 static_cast<AsyncCallbackInfoStickyCommonEvent *>(data);
1430             if (asyncCallbackInfo) {
1431                 napi_value result = nullptr;
1432                 napi_get_boolean(env, asyncCallbackInfo->isSticky, &result);
1433                 ReturnCallbackPromise(env, asyncCallbackInfo->info, result);
1434                 if (asyncCallbackInfo->info.callback != nullptr) {
1435                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1436                     EVENT_LOGD("Delete napiisStickyCommonEvent callback reference.");
1437                 }
1438                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1439                 delete asyncCallbackInfo;
1440                 asyncCallbackInfo = nullptr;
1441             }
1442             EVENT_LOGD("NapiisStickyCommonEvent work complete end.");
1443         },
1444         (void *)asyncCallbackInfo,
1445         &asyncCallbackInfo->asyncWork);
1446 
1447     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1448 
1449     if (asyncCallbackInfo->info.isCallback) {
1450         EVENT_LOGD("Delete napiisStickyCommonEvent callback reference.");
1451         return NapiGetNull(env);
1452     } else {
1453         return promise;
1454     }
1455 }
1456 
GetCode(napi_env env,napi_callback_info info)1457 napi_value GetCode(napi_env env, napi_callback_info info)
1458 {
1459     EVENT_LOGD("GetCode excute");
1460     size_t argc = 1;
1461     napi_value argv[1] = {nullptr};
1462     napi_value thisVar = nullptr;
1463     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1464 
1465     napi_ref callback = nullptr;
1466     if (ParseParametersByGetCode(env, argv, argc, callback) == nullptr) {
1467         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1468         return NapiGetNull(env);
1469     }
1470 
1471     AsyncCallbackInfoGetCode *asyncCallbackInfo =
1472         new (std::nothrow) AsyncCallbackInfoGetCode {.env = env, .asyncWork = nullptr};
1473     if (asyncCallbackInfo == nullptr) {
1474         EVENT_LOGE("asyncCallbackInfo is nullptr");
1475         return NapiGetNull(env);
1476     }
1477 
1478     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1479     if (asyncCallbackInfo->subscriber == nullptr) {
1480         EVENT_LOGE("GetSubscriber failed.");
1481         delete asyncCallbackInfo;
1482         return NapiGetNull(env);
1483     }
1484 
1485     napi_value promise = nullptr;
1486     PaddingAsyncCallbackInfoGetCode(env, argc, asyncCallbackInfo, callback, promise);
1487 
1488     napi_value resourceName = nullptr;
1489     napi_create_string_latin1(env, "getCode", NAPI_AUTO_LENGTH, &resourceName);
1490     // Asynchronous function call
1491     napi_create_async_work(env,
1492         nullptr,
1493         resourceName,
1494         [](napi_env env, void *data) {
1495             EVENT_LOGD("GetCode napi_create_async_work excute");
1496             AsyncCallbackInfoGetCode *asyncCallbackInfo = static_cast<AsyncCallbackInfoGetCode *>(data);
1497             if (asyncCallbackInfo) {
1498                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1499                     asyncCallbackInfo->subscriber.get());
1500                 if (asyncResult) {
1501                     EVENT_LOGD("get code success");
1502                     asyncCallbackInfo->code = asyncResult->GetCode();
1503                 } else {
1504                     EVENT_LOGD("get code failed");
1505                     asyncCallbackInfo->code = 0;
1506                 }
1507             }
1508         },
1509         [](napi_env env, napi_status status, void *data) {
1510             EVENT_LOGD("GetCode napi_create_async_work complete");
1511             AsyncCallbackInfoGetCode *asyncCallbackInfo = static_cast<AsyncCallbackInfoGetCode *>(data);
1512             if (asyncCallbackInfo) {
1513                 napi_value result = nullptr;
1514                 napi_create_int32(env, asyncCallbackInfo->code, &result);
1515                 ReturnCallbackPromise(env, asyncCallbackInfo->info, result);
1516                 if (asyncCallbackInfo->info.callback != nullptr) {
1517                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1518                     EVENT_LOGD("Delete napiGetCode callback reference.");
1519                 }
1520                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1521                 delete asyncCallbackInfo;
1522                 asyncCallbackInfo = nullptr;
1523             }
1524             EVENT_LOGD("NapiGetCode work complete end.");
1525         },
1526         (void *)asyncCallbackInfo,
1527         &asyncCallbackInfo->asyncWork);
1528 
1529     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1530 
1531     if (asyncCallbackInfo->info.isCallback) {
1532         EVENT_LOGD("Delete napiGetCode callback reference.");
1533         return NapiGetNull(env);
1534     } else {
1535         return promise;
1536     }
1537 }
1538 
GetData(napi_env env,napi_callback_info info)1539 napi_value GetData(napi_env env, napi_callback_info info)
1540 {
1541     EVENT_LOGD("GetData excute");
1542     size_t argc = 1;
1543     napi_value argv[1] = {nullptr};
1544     napi_value thisVar = nullptr;
1545     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1546 
1547     napi_ref callback = nullptr;
1548     if (ParseParametersByGetData(env, argv, argc, callback) == nullptr) {
1549         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1550         return NapiGetNull(env);
1551     }
1552 
1553     AsyncCallbackInfoGetData *asyncCallbackInfo =
1554         new (std::nothrow) AsyncCallbackInfoGetData {.env = env, .asyncWork = nullptr};
1555     if (asyncCallbackInfo == nullptr) {
1556         EVENT_LOGE("asyncCallbackInfo is nullptr");
1557         return NapiGetNull(env);
1558     }
1559 
1560     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1561     if (asyncCallbackInfo->subscriber == nullptr) {
1562         EVENT_LOGE("Failed to getSubscriber.");
1563         delete asyncCallbackInfo;
1564         return NapiGetNull(env);
1565     }
1566 
1567     napi_value promise = nullptr;
1568     PaddingAsyncCallbackInfoGetData(env, argc, asyncCallbackInfo, callback, promise);
1569 
1570     napi_value resourceName = nullptr;
1571     napi_create_string_latin1(env, "getData", NAPI_AUTO_LENGTH, &resourceName);
1572     // Calling Asynchronous functions
1573     napi_create_async_work(env,
1574         nullptr,
1575         resourceName,
1576         [](napi_env env, void *data) {
1577             EVENT_LOGD("GetData napi_create_async_work excute");
1578             AsyncCallbackInfoGetData *asyncCallbackInfo = static_cast<AsyncCallbackInfoGetData *>(data);
1579             if (asyncCallbackInfo) {
1580                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1581                     asyncCallbackInfo->subscriber.get());
1582                 if (asyncResult) {
1583                     asyncCallbackInfo->data = asyncResult->GetData();
1584                 } else {
1585                     asyncCallbackInfo->data = std::string();
1586                 }
1587             }
1588         },
1589         [](napi_env env, napi_status status, void *data) {
1590             EVENT_LOGD("GetData napi_create_async_work end");
1591             AsyncCallbackInfoGetData *asyncCallbackInfo = static_cast<AsyncCallbackInfoGetData *>(data);
1592             if (asyncCallbackInfo) {
1593                 napi_value result = nullptr;
1594                 napi_create_string_utf8(env, asyncCallbackInfo->data.c_str(), NAPI_AUTO_LENGTH, &result);
1595                 ReturnCallbackPromise(env, asyncCallbackInfo->info, result);
1596                 if (asyncCallbackInfo->info.callback != nullptr) {
1597                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1598                     EVENT_LOGD("Delete napiGetData callback reference.");
1599                 }
1600                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1601                 delete asyncCallbackInfo;
1602                 asyncCallbackInfo = nullptr;
1603             }
1604             EVENT_LOGD("NapiGetData work complete end.");
1605         },
1606         (void *)asyncCallbackInfo,
1607         &asyncCallbackInfo->asyncWork);
1608 
1609     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1610 
1611     if (asyncCallbackInfo->info.isCallback) {
1612         EVENT_LOGD("Delete napiGetData callback reference.");
1613         return NapiGetNull(env);
1614     } else {
1615         return promise;
1616     }
1617 }
1618 
AbortCommonEvent(napi_env env,napi_callback_info info)1619 napi_value AbortCommonEvent(napi_env env, napi_callback_info info)
1620 {
1621     EVENT_LOGD("enter");
1622     size_t argc = 1;
1623     napi_value argv[1] = {nullptr};
1624     napi_value thisVar = nullptr;
1625     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1626 
1627     napi_ref callback = nullptr;
1628     if (ParseParametersByAbort(env, argv, argc, callback) == nullptr) {
1629         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1630         return NapiGetNull(env);
1631     }
1632 
1633     AsyncCallbackInfoAbort *asyncCallbackInfo =
1634         new (std::nothrow) AsyncCallbackInfoAbort {.env = env, .asyncWork = nullptr};
1635     if (asyncCallbackInfo == nullptr) {
1636         EVENT_LOGE("asyncCallbackInfo is null");
1637         return NapiGetNull(env);
1638     }
1639 
1640     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1641     if (asyncCallbackInfo->subscriber == nullptr) {
1642         EVENT_LOGE("subscriber is null");
1643         delete asyncCallbackInfo;
1644         return NapiGetNull(env);
1645     }
1646     napi_value promise = nullptr;
1647     PaddingAsyncCallbackInfoAbort(env, argc, asyncCallbackInfo, callback, promise);
1648 
1649     napi_value resourceName = nullptr;
1650     napi_create_string_latin1(env, "abort", NAPI_AUTO_LENGTH, &resourceName);
1651     // Calling asynchronous function
1652     napi_create_async_work(env,
1653         nullptr,
1654         resourceName,
1655         [](napi_env env, void *data) {
1656             EVENT_LOGD("Abort napi_create_async_work excute");
1657             AsyncCallbackInfoAbort *asyncCallbackInfo = static_cast<AsyncCallbackInfoAbort *>(data);
1658             if (asyncCallbackInfo) {
1659                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1660                     asyncCallbackInfo->subscriber.get());
1661                 if (asyncResult) {
1662                     asyncCallbackInfo->info.errorCode = asyncResult->AbortCommonEvent() ? NO_ERROR : ERR_CES_FAILED;
1663                 }
1664             }
1665         },
1666         [](napi_env env, napi_status status, void *data) {
1667             EVENT_LOGD("Abort napi_create_async_work complete");
1668             AsyncCallbackInfoAbort *asyncCallbackInfo = static_cast<AsyncCallbackInfoAbort *>(data);
1669             if (asyncCallbackInfo) {
1670                 ReturnCallbackPromise(env, asyncCallbackInfo->info, NapiGetNull(env));
1671                 if (asyncCallbackInfo->info.callback != nullptr) {
1672                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1673                 }
1674                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1675                 delete asyncCallbackInfo;
1676                 asyncCallbackInfo = nullptr;
1677                 EVENT_LOGD("NapiAbort work complete end.");
1678             }
1679         },
1680         (void *)asyncCallbackInfo,
1681         &asyncCallbackInfo->asyncWork);
1682 
1683     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1684 
1685     if (asyncCallbackInfo->info.isCallback) {
1686         EVENT_LOGD("Delete napiAbort callback reference.");
1687         return NapiGetNull(env);
1688     } else {
1689         return promise;
1690     }
1691 }
1692 
ClearAbortCommonEvent(napi_env env,napi_callback_info info)1693 napi_value ClearAbortCommonEvent(napi_env env, napi_callback_info info)
1694 {
1695     EVENT_LOGD("ClearAbort start");
1696     size_t argc = 1;
1697     napi_value argv[1] = {nullptr};
1698     napi_value thisVar = nullptr;
1699     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1700 
1701     napi_ref callback = nullptr;
1702     if (ParseParametersByClearAbort(env, argv, argc, callback) == nullptr) {
1703         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1704         return NapiGetNull(env);
1705     }
1706 
1707     AsyncCallbackInfoClearAbort *asyncCallbackInfo =
1708         new (std::nothrow) AsyncCallbackInfoClearAbort {.env = env, .asyncWork = nullptr};
1709     if (asyncCallbackInfo == nullptr) {
1710         EVENT_LOGE("Create asyncCallbackInfo defeat");
1711         return NapiGetNull(env);
1712     }
1713 
1714     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1715     if (asyncCallbackInfo->subscriber == nullptr) {
1716         EVENT_LOGE("subscriber is null");
1717         delete asyncCallbackInfo;
1718         return NapiGetNull(env);
1719     }
1720 
1721     napi_value promise = nullptr;
1722     PaddingAsyncCallbackInfoClearAbort(env, argc, asyncCallbackInfo, callback, promise);
1723 
1724     napi_value resourceName = nullptr;
1725     napi_create_string_latin1(env, "clearAbort", NAPI_AUTO_LENGTH, &resourceName);
1726     // Calling Asynchronous functions
1727     napi_create_async_work(env,
1728         nullptr,
1729         resourceName,
1730         [](napi_env env, void *data) {
1731             EVENT_LOGD("ClearAbort napi_create_async_work start");
1732             AsyncCallbackInfoClearAbort *asyncCallbackInfo = static_cast<AsyncCallbackInfoClearAbort *>(data);
1733             if (asyncCallbackInfo) {
1734                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1735                     asyncCallbackInfo->subscriber.get());
1736                 if (asyncResult) {
1737                     asyncCallbackInfo->info.errorCode =
1738                         asyncResult->ClearAbortCommonEvent() ? NO_ERROR : ERR_CES_FAILED;
1739                 }
1740             }
1741         },
1742         [](napi_env env, napi_status status, void *data) {
1743             EVENT_LOGD("ClearAbort napi_create_async_work complete");
1744             AsyncCallbackInfoClearAbort *asyncCallbackInfo = static_cast<AsyncCallbackInfoClearAbort *>(data);
1745             if (asyncCallbackInfo) {
1746                 ReturnCallbackPromise(env, asyncCallbackInfo->info, NapiGetNull(env));
1747                 if (asyncCallbackInfo->info.callback != nullptr) {
1748                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1749                 }
1750                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1751                 delete asyncCallbackInfo;
1752                 asyncCallbackInfo = nullptr;
1753                 EVENT_LOGD("NapiClearAbort work complete end.");
1754             }
1755         },
1756         (void *)asyncCallbackInfo,
1757         &asyncCallbackInfo->asyncWork);
1758 
1759     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1760 
1761     if (asyncCallbackInfo->info.isCallback) {
1762         EVENT_LOGD("Delete napiClearAbort callback reference.");
1763         return NapiGetNull(env);
1764     } else {
1765         return promise;
1766     }
1767 }
1768 
GetAbortCommonEvent(napi_env env,napi_callback_info info)1769 napi_value GetAbortCommonEvent(napi_env env, napi_callback_info info)
1770 {
1771     EVENT_LOGD("GetAbort excute");
1772     size_t argc = 1;
1773     napi_value argv[1] = {nullptr};
1774     napi_value thisVar = nullptr;
1775     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1776 
1777     napi_ref callback = nullptr;
1778     if (ParseParametersByGetAbort(env, argv, argc, callback) == nullptr) {
1779         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1780         return NapiGetNull(env);
1781     }
1782 
1783     AsyncCallbackInfoGetAbort *asyncCallbackInfo =
1784         new (std::nothrow) AsyncCallbackInfoGetAbort {.env = env, .asyncWork = nullptr};
1785     if (asyncCallbackInfo == nullptr) {
1786         EVENT_LOGE("Create asyncCallbackInfo is failed");
1787         return NapiGetNull(env);
1788     }
1789 
1790     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1791     if (asyncCallbackInfo->subscriber == nullptr) {
1792         EVENT_LOGE("subscriber is null");
1793         delete asyncCallbackInfo;
1794         return NapiGetNull(env);
1795     }
1796 
1797     napi_value promise = nullptr;
1798     PaddingAsyncCallbackInfoGetAbort(env, argc, asyncCallbackInfo, callback, promise);
1799 
1800     napi_value resourceName = nullptr;
1801     napi_create_string_latin1(env, "getAbort", NAPI_AUTO_LENGTH, &resourceName);
1802     // Asynchronous function call
1803     napi_create_async_work(env,
1804         nullptr,
1805         resourceName,
1806         [](napi_env env, void *data) {
1807             EVENT_LOGD("Excute create async GetAbort");
1808             AsyncCallbackInfoGetAbort *asyncCallbackInfo = static_cast<AsyncCallbackInfoGetAbort *>(data);
1809             if (asyncCallbackInfo) {
1810                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1811                     asyncCallbackInfo->subscriber.get());
1812                 if (asyncResult) {
1813                     asyncCallbackInfo->abortEvent = asyncResult->GetAbortCommonEvent();
1814                 } else {
1815                     asyncCallbackInfo->abortEvent = false;
1816                 }
1817             }
1818         },
1819         [](napi_env env, napi_status status, void *data) {
1820             EVENT_LOGD("GetAbort napi_create_async_work complete");
1821             AsyncCallbackInfoGetAbort *asyncCallbackInfo = static_cast<AsyncCallbackInfoGetAbort *>(data);
1822             if (asyncCallbackInfo) {
1823                 napi_value result = nullptr;
1824                 napi_get_boolean(env, asyncCallbackInfo->abortEvent, &result);
1825                 ReturnCallbackPromise(env, asyncCallbackInfo->info, result);
1826                 if (asyncCallbackInfo->info.callback != nullptr) {
1827                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1828                     EVENT_LOGD("Delete napiGetAbort callback reference.");
1829                 }
1830                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1831                 delete asyncCallbackInfo;
1832                 asyncCallbackInfo = nullptr;
1833             }
1834             EVENT_LOGD("NapiGetAbort work complete end.");
1835         },
1836         (void *)asyncCallbackInfo,
1837         &asyncCallbackInfo->asyncWork);
1838 
1839     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1840 
1841     if (asyncCallbackInfo->info.isCallback) {
1842         EVENT_LOGD("Delete napiGetAbort callback reference.");
1843         return NapiGetNull(env);
1844     } else {
1845         return promise;
1846     }
1847 }
1848 
FinishCommonEvent(napi_env env,napi_callback_info info)1849 napi_value FinishCommonEvent(napi_env env, napi_callback_info info)
1850 {
1851     EVENT_LOGD("Finish excute");
1852     size_t argc = 1;
1853     napi_value argv[1] = {nullptr};
1854     napi_value thisVar = nullptr;
1855     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
1856 
1857     napi_ref callback = nullptr;
1858     if (ParseParametersByFinish(env, argv, argc, callback) == nullptr) {
1859         NapiThrow(env, ERR_NOTIFICATION_CES_COMMON_PARAM_INVALID);
1860         return NapiGetNull(env);
1861     }
1862 
1863     AsyncCallbackInfoFinish *asyncCallbackInfo =
1864         new (std::nothrow) AsyncCallbackInfoFinish {.env = env, .asyncWork = nullptr};
1865     if (asyncCallbackInfo == nullptr) {
1866         EVENT_LOGE("asyncCallbackInfo is nullptr");
1867         return NapiGetNull(env);
1868     }
1869 
1870     asyncCallbackInfo->subscriber = GetSubscriber(env, thisVar);
1871     if (asyncCallbackInfo->subscriber == nullptr) {
1872         EVENT_LOGE("subscriber is null");
1873         delete asyncCallbackInfo;
1874         return NapiGetNull(env);
1875     }
1876 
1877     napi_value promise = nullptr;
1878     PaddingAsyncCallbackInfoFinish(env, argc, asyncCallbackInfo, callback, promise);
1879 
1880     napi_value resourceName = nullptr;
1881     napi_create_string_latin1(env, "finish", NAPI_AUTO_LENGTH, &resourceName);
1882     // Asynchronous function call
1883     napi_create_async_work(env,
1884         nullptr,
1885         resourceName,
1886         [](napi_env env, void *data) {
1887             EVENT_LOGD("Finish napi_create_async_work start");
1888             AsyncCallbackInfoFinish *asyncCallbackInfo = static_cast<AsyncCallbackInfoFinish *>(data);
1889             if (asyncCallbackInfo) {
1890                 std::shared_ptr<AsyncCommonEventResult> asyncResult = GetAsyncResult(
1891                     asyncCallbackInfo->subscriber.get());
1892                 if (asyncResult) {
1893                     asyncCallbackInfo->info.errorCode = asyncResult->FinishCommonEvent() ? NO_ERROR : ERR_CES_FAILED;
1894                 }
1895             }
1896         },
1897         [](napi_env env, napi_status status, void *data) {
1898             EVENT_LOGD("Finish napi_create_async_work complete");
1899             AsyncCallbackInfoFinish *asyncCallbackInfo = static_cast<AsyncCallbackInfoFinish *>(data);
1900             if (asyncCallbackInfo) {
1901                 ReturnCallbackPromise(env, asyncCallbackInfo->info, NapiGetNull(env));
1902                 if (asyncCallbackInfo->info.callback != nullptr) {
1903                     napi_delete_reference(env, asyncCallbackInfo->info.callback);
1904                 }
1905                 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1906                 delete asyncCallbackInfo;
1907                 asyncCallbackInfo = nullptr;
1908                 EVENT_LOGD("NapiFinish work complete end.");
1909             }
1910         },
1911         (void *)asyncCallbackInfo,
1912         &asyncCallbackInfo->asyncWork);
1913 
1914     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
1915 
1916     if (asyncCallbackInfo->info.isCallback) {
1917         EVENT_LOGD("Delete napiFinish callback reference.");
1918         return NapiGetNull(env);
1919     } else {
1920         return promise;
1921     }
1922 }
CommonEventManagerInit(napi_env env,napi_value exports)1923 napi_value CommonEventManagerInit(napi_env env, napi_value exports)
1924 {
1925     EVENT_LOGD("enter");
1926     napi_property_descriptor desc[] = {
1927         DECLARE_NAPI_FUNCTION("publish", Publish),
1928         DECLARE_NAPI_FUNCTION("publishAsUser", PublishAsUser),
1929         DECLARE_NAPI_FUNCTION("createSubscriber", CreateSubscriber),
1930         DECLARE_NAPI_FUNCTION("createSubscriberSync", CreateSubscriberSync),
1931         DECLARE_NAPI_FUNCTION("subscribe", Subscribe),
1932         DECLARE_NAPI_FUNCTION("unsubscribe", Unsubscribe),
1933         DECLARE_NAPI_FUNCTION("removeStickyCommonEvent", RemoveStickyCommonEvent),
1934     };
1935 
1936     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
1937 
1938     OHOS::EventFwkNapi::SupportInit(env, exports);
1939     return NapiStaicSubscribeInit(env, exports);
1940 }
1941 
CommonEventSubscriberInit(napi_env env,napi_value exports)1942 napi_value CommonEventSubscriberInit(napi_env env, napi_value exports)
1943 {
1944     EVENT_LOGD("enter");
1945     napi_value constructor = nullptr;
1946     napi_property_descriptor properties[] = {
1947         DECLARE_NAPI_FUNCTION("getSubscribeInfo", GetSubscribeInfo),
1948         DECLARE_NAPI_FUNCTION("getSubscribeInfoSync", GetSubscribeInfoSync),
1949         DECLARE_NAPI_FUNCTION("isOrderedCommonEvent", IsOrderedCommonEvent),
1950         DECLARE_NAPI_FUNCTION("isOrderedCommonEventSync", IsOrderedCommonEventSync),
1951         DECLARE_NAPI_FUNCTION("isStickyCommonEvent", IsStickyCommonEvent),
1952         DECLARE_NAPI_FUNCTION("isStickyCommonEventSync", IsStickyCommonEventSync),
1953         DECLARE_NAPI_FUNCTION("getCode", GetCode),
1954         DECLARE_NAPI_FUNCTION("getCodeSync", GetCodeSync),
1955         DECLARE_NAPI_FUNCTION("setCode", SetCode),
1956         DECLARE_NAPI_FUNCTION("setCodeSync", SetCodeSync),
1957         DECLARE_NAPI_FUNCTION("getData", GetData),
1958         DECLARE_NAPI_FUNCTION("getDataSync", GetDataSync),
1959         DECLARE_NAPI_FUNCTION("setData", SetData),
1960         DECLARE_NAPI_FUNCTION("setDataSync", SetDataSync),
1961         DECLARE_NAPI_FUNCTION("setCodeAndData", SetCodeAndData),
1962         DECLARE_NAPI_FUNCTION("setCodeAndDataSync", SetCodeAndDataSync),
1963         DECLARE_NAPI_FUNCTION("abortCommonEvent", AbortCommonEvent),
1964         DECLARE_NAPI_FUNCTION("abortCommonEventSync", AbortCommonEventSync),
1965         DECLARE_NAPI_FUNCTION("clearAbortCommonEvent", ClearAbortCommonEvent),
1966         DECLARE_NAPI_FUNCTION("clearAbortCommonEventSync", ClearAbortCommonEventSync),
1967         DECLARE_NAPI_FUNCTION("getAbortCommonEvent", GetAbortCommonEvent),
1968         DECLARE_NAPI_FUNCTION("getAbortCommonEventSync", GetAbortCommonEventSync),
1969         DECLARE_NAPI_FUNCTION("finishCommonEvent", FinishCommonEvent),
1970     };
1971 
1972     NAPI_CALL(env,
1973         napi_define_class(env,
1974             "commonEventSubscriber",
1975             NAPI_AUTO_LENGTH,
1976             CommonEventSubscriberConstructor,
1977             nullptr,
1978             sizeof(properties) / sizeof(*properties),
1979             properties,
1980             &constructor));
1981 
1982     napi_create_reference(env, constructor, 1, &g_CommonEventSubscriber);
1983     napi_set_named_property(env, exports, "commonEventSubscriber", constructor);
1984     return exports;
1985 }
1986 
1987 }  // namespace EventManagerFwkNapi
1988 }  // namespace OHOS
1989