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