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_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 bool isCallback = asynccallbackinfo->info.isCallback;
78 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
79 if (status != napi_ok) {
80 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
81 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
82 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
83 if (asynccallbackinfo->info.callback != nullptr) {
84 napi_delete_reference(env, asynccallbackinfo->info.callback);
85 }
86 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
87 delete asynccallbackinfo;
88 asynccallbackinfo = nullptr;
89 }
90
91 if (isCallback) {
92 return Common::NapiGetNull(env);
93 } else {
94 return promise;
95 }
96 }
97
NapiShowNotification(napi_env env,napi_callback_info info)98 napi_value NapiShowNotification(napi_env env, napi_callback_info info)
99 {
100 ANS_LOGI("enter");
101 ParametersInfoPublish params;
102 if (ParseShowOptions(env, info, params) == nullptr) {
103 ANS_LOGW("parse showOptions failed");
104 Common::NapiThrow(env, ERROR_PARAM_INVALID);
105 return Common::NapiGetUndefined(env);
106 }
107
108 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
109 if (!asynccallbackinfo) {
110 ANS_LOGW("failed to create asynccallbackinfo");
111 return Common::JSParaError(env, params.callback);
112 }
113 asynccallbackinfo->request = params.request;
114
115 napi_value resourceName = nullptr;
116 napi_create_string_latin1(env, "show", NAPI_AUTO_LENGTH, &resourceName);
117
118 ANS_LOGI("before napi_create_async_work");
119 napi_create_async_work(env,
120 nullptr,
121 resourceName,
122 [](napi_env env, void *data) {
123 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
124 if (asynccallbackinfo) {
125 ANS_LOGI("Show napi_create_async_work start notificationId = %{public}d, contentType = "
126 "%{public}d",
127 asynccallbackinfo->request.GetNotificationId(),
128 asynccallbackinfo->request.GetContent()->GetContentType());
129
130 asynccallbackinfo->info.errorCode =
131 NotificationHelper::PublishNotification(asynccallbackinfo->request);
132 }
133 },
134 [](napi_env env, napi_status status, void *data) {
135 ANS_LOGI("Show napi_create_async_work complete start");
136 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
137 if (asynccallbackinfo) {
138 if (asynccallbackinfo->info.callback != nullptr) {
139 napi_delete_reference(env, asynccallbackinfo->info.callback);
140 }
141 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
142 delete asynccallbackinfo;
143 asynccallbackinfo = nullptr;
144 }
145 ANS_LOGI("Show napi_create_async_work complete end");
146 },
147 (void *)asynccallbackinfo,
148 &asynccallbackinfo->asyncWork);
149
150 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
151 if (status != napi_ok) {
152 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
153 if (asynccallbackinfo->info.callback != nullptr) {
154 napi_delete_reference(env, asynccallbackinfo->info.callback);
155 }
156 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
157 delete asynccallbackinfo;
158 asynccallbackinfo = nullptr;
159 }
160 return nullptr;
161 }
162
NapiPublishAsBundle(napi_env env,napi_callback_info info)163 napi_value NapiPublishAsBundle(napi_env env, napi_callback_info info)
164 {
165 ANS_LOGI("enter");
166 ParametersInfoPublish params;
167 if (ParsePublishAsBundleParameters(env, info, params) == nullptr) {
168 Common::NapiThrow(env, ERROR_PARAM_INVALID);
169 return Common::NapiGetUndefined(env);
170 }
171
172 napi_value promise = nullptr;
173 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoPublish {.env = env, .asyncWork = nullptr};
174 if (!asynccallbackinfo) {
175 return Common::JSParaError(env, params.callback);
176 }
177
178 asynccallbackinfo->request = params.request;
179 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
180
181 napi_value resourceName = nullptr;
182 napi_create_string_latin1(env, "publishasbundle", NAPI_AUTO_LENGTH, &resourceName);
183
184 napi_create_async_work(env,
185 nullptr,
186 resourceName,
187 [](napi_env env, void *data) {
188 ANS_LOGI("PublishAsBundle napi_create_async_work start");
189 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
190 if (asynccallbackinfo) {
191 ANS_LOGI("PublishAsBundle napi_create_async_work start notificationId = %{public}d, contentType = "
192 "%{public}d",
193 asynccallbackinfo->request.GetNotificationId(),
194 asynccallbackinfo->request.GetContent()->GetContentType());
195
196 asynccallbackinfo->info.errorCode =
197 NotificationHelper::PublishNotification(asynccallbackinfo->request);
198 }
199 },
200 [](napi_env env, napi_status status, void *data) {
201 ANS_LOGI("PublishAsBundle napi_create_async_work complete start");
202 AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
203 if (asynccallbackinfo) {
204 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
205 if (asynccallbackinfo->info.callback != nullptr) {
206 napi_delete_reference(env, asynccallbackinfo->info.callback);
207 }
208 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
209 delete asynccallbackinfo;
210 asynccallbackinfo = nullptr;
211 }
212 ANS_LOGI("PublishAsBundle napi_create_async_work complete end");
213 },
214 (void *)asynccallbackinfo,
215 &asynccallbackinfo->asyncWork);
216
217 bool isCallback = asynccallbackinfo->info.isCallback;
218 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
219 if (status != napi_ok) {
220 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
221 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
222 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
223 if (asynccallbackinfo->info.callback != nullptr) {
224 napi_delete_reference(env, asynccallbackinfo->info.callback);
225 }
226 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
227 delete asynccallbackinfo;
228 asynccallbackinfo = nullptr;
229 }
230
231 if (isCallback) {
232 return Common::NapiGetNull(env);
233 } else {
234 return promise;
235 }
236 }
237 } // namespace NotificationNapi
238 } // namespace OHOS