1 /*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi_display_badge.h"
17
18 #include "ans_inner_errors.h"
19 #include "display_badge.h"
20
21 namespace OHOS {
22 namespace NotificationNapi {
NapiDisplayBadge(napi_env env,napi_callback_info info)23 napi_value NapiDisplayBadge(napi_env env, napi_callback_info info)
24 {
25 ANS_LOGI("enter");
26 EnableBadgeParams params {};
27 if (ParseParameters(env, info, params) == nullptr) {
28 Common::NapiThrow(env, ERROR_PARAM_INVALID);
29 return Common::NapiGetUndefined(env);
30 }
31
32 AsyncCallbackInfoEnableBadge *asynccallbackinfo =
33 new (std::nothrow) AsyncCallbackInfoEnableBadge {.env = env, .asyncWork = nullptr, .params = params};
34 if (!asynccallbackinfo) {
35 return Common::JSParaError(env, params.callback);
36 }
37 napi_value promise = nullptr;
38 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
39
40 napi_value resourceName = nullptr;
41 napi_create_string_latin1(env, "DisplayBadge", NAPI_AUTO_LENGTH, &resourceName);
42 // Asynchronous function call
43 napi_create_async_work(env,
44 nullptr,
45 resourceName,
46 [](napi_env env, void *data) {
47 ANS_LOGI("DisplayBadge napi_create_async_work start");
48 AsyncCallbackInfoEnableBadge *asynccallbackinfo = static_cast<AsyncCallbackInfoEnableBadge *>(data);
49 if (asynccallbackinfo) {
50 ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d enable = %{public}d",
51 asynccallbackinfo->params.option.GetBundleName().c_str(),
52 asynccallbackinfo->params.option.GetUid(),
53 asynccallbackinfo->params.enable);
54 asynccallbackinfo->info.errorCode = NotificationHelper::SetShowBadgeEnabledForBundle(
55 asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
56 ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
57 }
58 },
59 [](napi_env env, napi_status status, void *data) {
60 ANS_LOGI("DisplayBadge napi_create_async_work end");
61 AsyncCallbackInfoEnableBadge *asynccallbackinfo = static_cast<AsyncCallbackInfoEnableBadge *>(data);
62 if (asynccallbackinfo) {
63 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
64 if (asynccallbackinfo->info.callback != nullptr) {
65 napi_delete_reference(env, asynccallbackinfo->info.callback);
66 }
67 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
68 delete asynccallbackinfo;
69 asynccallbackinfo = nullptr;
70 }
71 },
72 (void *)asynccallbackinfo,
73 &asynccallbackinfo->asyncWork);
74
75 bool isCallback = asynccallbackinfo->info.isCallback;
76 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
77 if (status != napi_ok) {
78 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
79 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
80 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
81 if (asynccallbackinfo->info.callback != nullptr) {
82 napi_delete_reference(env, asynccallbackinfo->info.callback);
83 }
84 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
85 delete asynccallbackinfo;
86 asynccallbackinfo = nullptr;
87 }
88
89 if (isCallback) {
90 return Common::NapiGetNull(env);
91 } else {
92 return promise;
93 }
94 }
95
AsyncCompleteCallbackNapiIsBadgeDisplayed(napi_env env,napi_status status,void * data)96 void AsyncCompleteCallbackNapiIsBadgeDisplayed(napi_env env, napi_status status, void *data)
97 {
98 ANS_LOGI("enter");
99 if (!data) {
100 ANS_LOGE("Invalid async callback data");
101 return;
102 }
103 AsyncCallbackInfoIsDisplayBadge *asynccallbackinfo = static_cast<AsyncCallbackInfoIsDisplayBadge *>(data);
104 if (asynccallbackinfo) {
105 napi_value result = nullptr;
106 napi_get_boolean(env, asynccallbackinfo->enabled, &result);
107 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
108 if (asynccallbackinfo->info.callback != nullptr) {
109 napi_delete_reference(env, asynccallbackinfo->info.callback);
110 }
111 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
112 delete asynccallbackinfo;
113 asynccallbackinfo = nullptr;
114 }
115 }
116
NapiIsBadgeDisplayed(napi_env env,napi_callback_info info)117 napi_value NapiIsBadgeDisplayed(napi_env env, napi_callback_info info)
118 {
119 ANS_LOGI("enter");
120 IsDisplayBadgeParams params {};
121 if (ParseParameters(env, info, params) == nullptr) {
122 ANS_LOGE("Failed to parse params!");
123 Common::NapiThrow(env, ERROR_PARAM_INVALID);
124 return Common::NapiGetUndefined(env);
125 }
126
127 AsyncCallbackInfoIsDisplayBadge *asynccallbackinfo =
128 new (std::nothrow) AsyncCallbackInfoIsDisplayBadge {.env = env, .asyncWork = nullptr, .params = params};
129 if (!asynccallbackinfo) {
130 return Common::JSParaError(env, params.callback);
131 }
132 napi_value promise = nullptr;
133 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
134
135 napi_value resourceName = nullptr;
136 napi_create_string_latin1(env, "IsBadgeDisplayed", NAPI_AUTO_LENGTH, &resourceName);
137 // Asynchronous function call
138 napi_create_async_work(env,
139 nullptr,
140 resourceName,
141 [](napi_env env, void *data) {
142 ANS_LOGI("IsBadgeDisplayed napi_create_async_work start");
143 AsyncCallbackInfoIsDisplayBadge *asynccallbackinfo = static_cast<AsyncCallbackInfoIsDisplayBadge *>(data);
144 if (asynccallbackinfo) {
145 if (asynccallbackinfo->params.hasBundleOption) {
146 ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d",
147 asynccallbackinfo->params.option.GetBundleName().c_str(),
148 asynccallbackinfo->params.option.GetUid());
149 asynccallbackinfo->info.errorCode = NotificationHelper::GetShowBadgeEnabledForBundle(
150 asynccallbackinfo->params.option, asynccallbackinfo->enabled);
151 } else {
152 asynccallbackinfo->info.errorCode = NotificationHelper::GetShowBadgeEnabled(
153 asynccallbackinfo->enabled);
154 }
155 ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, enabled = %{public}d",
156 asynccallbackinfo->info.errorCode, asynccallbackinfo->enabled);
157 }
158 },
159 AsyncCompleteCallbackNapiIsBadgeDisplayed,
160 (void *)asynccallbackinfo,
161 &asynccallbackinfo->asyncWork);
162
163 bool isCallback = asynccallbackinfo->info.isCallback;
164 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
165 if (status != napi_ok) {
166 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
167 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
168 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
169 if (asynccallbackinfo->info.callback != nullptr) {
170 napi_delete_reference(env, asynccallbackinfo->info.callback);
171 }
172 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
173 delete asynccallbackinfo;
174 asynccallbackinfo = nullptr;
175 }
176
177 if (isCallback) {
178 return Common::NapiGetNull(env);
179 } else {
180 return promise;
181 }
182 }
183 } // namespace NotificationNapi
184 } // namespace OHOS