1 /*
2 * Copyright (c) 2022 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_publish.h"
17
18 #include "ans_inner_errors.h"
19 #include "publish.h"
20
21 namespace OHOS {
22 namespace NotificationNapi {
23
NapiPublish(napi_env env,napi_callback_info info)24 napi_value NapiPublish(napi_env env, napi_callback_info info)
25 {
26 ANS_LOGI("enter");
27 ParametersInfoPublish params;
28 if (ParseParameters(env, info, params) == nullptr) {
29 Common::NapiThrow(env, ERROR_PARAM_INVALID);
30 return Common::NapiGetUndefined(env);
31 }
32
33 napi_value promise = nullptr;
34 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
35 if (!asynccallbackinfo) {
36 return Common::JSParaError(env, params.callback);
37 }
38 asynccallbackinfo->request = params.request;
39 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
40
41 napi_value resourceName = nullptr;
42 napi_create_string_latin1(env, "publish", NAPI_AUTO_LENGTH, &resourceName);
43
44 napi_create_async_work(env,
45 nullptr,
46 resourceName,
47 [](napi_env env, void *data) {
48 ANS_LOGI("Publish napi_create_async_work start");
49 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
50 if (asynccallbackinfo) {
51 ANS_LOGI("Publish napi_create_async_work start notificationId = %{public}d, contentType = "
52 "%{public}d",
53 asynccallbackinfo->request.GetNotificationId(),
54 asynccallbackinfo->request.GetContent()->GetContentType());
55
56 asynccallbackinfo->info.errorCode =
57 NotificationHelper::PublishNotification(asynccallbackinfo->request);
58 }
59 },
60 [](napi_env env, napi_status status, void *data) {
61 ANS_LOGI("Publish napi_create_async_work complete start");
62 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
63 if (asynccallbackinfo) {
64 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
65 if (asynccallbackinfo->info.callback != nullptr) {
66 napi_delete_reference(env, asynccallbackinfo->info.callback);
67 }
68 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
69 delete asynccallbackinfo;
70 asynccallbackinfo = nullptr;
71 }
72 ANS_LOGI("Publish napi_create_async_work complete end");
73 },
74 (void *)asynccallbackinfo,
75 &asynccallbackinfo->asyncWork);
76
77 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
78 if (asynccallbackinfo->info.isCallback) {
79 return Common::NapiGetNull(env);
80 } else {
81 return promise;
82 }
83 }
84
NapiShowNotification(napi_env env,napi_callback_info info)85 napi_value NapiShowNotification(napi_env env, napi_callback_info info)
86 {
87 ANS_LOGI("enter");
88 ParametersInfoPublish params;
89 if (ParseShowOptions(env, info, params) == nullptr) {
90 ANS_LOGW("parse showOptions failed");
91 Common::NapiThrow(env, ERROR_PARAM_INVALID);
92 return Common::NapiGetUndefined(env);
93 }
94
95 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
96 if (!asynccallbackinfo) {
97 ANS_LOGW("failed to create asynccallbackinfo");
98 return Common::JSParaError(env, params.callback);
99 }
100 asynccallbackinfo->request = params.request;
101
102 napi_value resourceName = nullptr;
103 napi_create_string_latin1(env, "show", NAPI_AUTO_LENGTH, &resourceName);
104
105 ANS_LOGI("before napi_create_async_work");
106 napi_create_async_work(env,
107 nullptr,
108 resourceName,
109 [](napi_env env, void *data) {
110 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
111 if (asynccallbackinfo) {
112 ANS_LOGI("Show napi_create_async_work start notificationId = %{public}d, contentType = "
113 "%{public}d",
114 asynccallbackinfo->request.GetNotificationId(),
115 asynccallbackinfo->request.GetContent()->GetContentType());
116
117 asynccallbackinfo->info.errorCode =
118 NotificationHelper::PublishNotification(asynccallbackinfo->request);
119 }
120 },
121 [](napi_env env, napi_status status, void *data) {
122 ANS_LOGI("Show napi_create_async_work complete start");
123 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
124 if (asynccallbackinfo) {
125 if (asynccallbackinfo->info.callback != nullptr) {
126 napi_delete_reference(env, asynccallbackinfo->info.callback);
127 }
128 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
129 delete asynccallbackinfo;
130 asynccallbackinfo = nullptr;
131 }
132 ANS_LOGI("Show napi_create_async_work complete end");
133 },
134 (void *)asynccallbackinfo,
135 &asynccallbackinfo->asyncWork);
136
137 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
138 return nullptr;
139 }
140
NapiPublishAsBundle(napi_env env,napi_callback_info info)141 napi_value NapiPublishAsBundle(napi_env env, napi_callback_info info)
142 {
143 ANS_LOGI("enter");
144 ParametersInfoPublish params;
145 if (ParsePublishAsBundleParameters(env, info, params) == nullptr) {
146 Common::NapiThrow(env, ERROR_PARAM_INVALID);
147 return Common::NapiGetUndefined(env);
148 }
149
150 napi_value promise = nullptr;
151 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
152 if (!asynccallbackinfo) {
153 return Common::JSParaError(env, params.callback);
154 }
155
156 asynccallbackinfo->request = params.request;
157 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
158
159 napi_value resourceName = nullptr;
160 napi_create_string_latin1(env, "publishasbundle", NAPI_AUTO_LENGTH, &resourceName);
161
162 napi_create_async_work(env,
163 nullptr,
164 resourceName,
165 [](napi_env env, void *data) {
166 ANS_LOGI("PublishAsBundle napi_create_async_work start");
167 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
168 if (asynccallbackinfo) {
169 ANS_LOGI("PublishAsBundle napi_create_async_work start notificationId = %{public}d, contentType = "
170 "%{public}d",
171 asynccallbackinfo->request.GetNotificationId(),
172 asynccallbackinfo->request.GetContent()->GetContentType());
173
174 asynccallbackinfo->info.errorCode =
175 NotificationHelper::PublishNotification(asynccallbackinfo->request);
176 }
177 },
178 [](napi_env env, napi_status status, void *data) {
179 ANS_LOGI("PublishAsBundle napi_create_async_work complete start");
180 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
181 if (asynccallbackinfo) {
182 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
183 if (asynccallbackinfo->info.callback != nullptr) {
184 napi_delete_reference(env, asynccallbackinfo->info.callback);
185 }
186 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
187 delete asynccallbackinfo;
188 asynccallbackinfo = nullptr;
189 }
190 ANS_LOGI("PublishAsBundle napi_create_async_work complete end");
191 },
192 (void *)asynccallbackinfo,
193 &asynccallbackinfo->asyncWork);
194
195 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
196 if (asynccallbackinfo->info.isCallback) {
197 return Common::NapiGetNull(env);
198 } else {
199 return promise;
200 }
201 }
202 } // namespace NotificationNapi
203 } // namespace OHOS