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_subscribe.h"
17
18 #include "ans_inner_errors.h"
19 #include "subscribe.h"
20 #include "unsubscribe.h"
21
22 namespace OHOS {
23 namespace NotificationNapi {
NapiSubscribe(napi_env env,napi_callback_info info)24 napi_value NapiSubscribe(napi_env env, napi_callback_info info)
25 {
26 ANS_LOGI("enter");
27 napi_ref callback = nullptr;
28 SubscriberInstance *objectInfo = nullptr;
29 NotificationSubscribeInfo subscriberInfo;
30 if (ParseParameters(env, info, subscriberInfo, objectInfo, callback) == nullptr) {
31 if (objectInfo) {
32 delete objectInfo;
33 objectInfo = nullptr;
34 }
35 Common::NapiThrow(env, ERROR_PARAM_INVALID);
36 return Common::NapiGetUndefined(env);
37 }
38
39 AsyncCallbackInfoSubscribe *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoSubscribe {
40 .env = env, .asyncWork = nullptr, .objectInfo = objectInfo, .subscriberInfo = subscriberInfo
41 };
42 if (!asynccallbackinfo) {
43 if (objectInfo) {
44 delete objectInfo;
45 objectInfo = nullptr;
46 }
47 return Common::JSParaError(env, callback);
48 }
49 napi_value promise = nullptr;
50 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
51
52 napi_value resourceName = nullptr;
53 napi_create_string_latin1(env, "subscribeNotification", NAPI_AUTO_LENGTH, &resourceName);
54 // Asynchronous function call
55 napi_create_async_work(env,
56 nullptr,
57 resourceName,
58 [](napi_env env, void *data) {
59 ANS_LOGI("Subscribe napi_create_async_work start");
60 if (!data) {
61 ANS_LOGE("Invalid asynccallbackinfo!");
62 return;
63 }
64 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoSubscribe *>(data);
65 if (asynccallbackinfo) {
66 if (asynccallbackinfo->subscriberInfo.hasSubscribeInfo) {
67 ANS_LOGI("Subscribe with NotificationSubscribeInfo");
68 OHOS::Notification::NotificationSubscribeInfo subscribeInfo;
69 subscribeInfo.AddAppNames(asynccallbackinfo->subscriberInfo.bundleNames);
70 subscribeInfo.AddAppUserId(asynccallbackinfo->subscriberInfo.userId);
71 asynccallbackinfo->info.errorCode =
72 NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo), subscribeInfo);
73 } else {
74 asynccallbackinfo->info.errorCode =
75 NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo));
76 }
77 }
78 },
79 [](napi_env env, napi_status status, void *data) {
80 ANS_LOGI("Subscribe napi_create_async_work end");
81 if (!data) {
82 ANS_LOGE("Invalid asynccallbackinfo!");
83 return;
84 }
85 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoSubscribe *>(data);
86 if (asynccallbackinfo) {
87 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
88
89 if (asynccallbackinfo->info.callback != nullptr) {
90 napi_delete_reference(env, asynccallbackinfo->info.callback);
91 }
92 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
93
94 delete asynccallbackinfo;
95 asynccallbackinfo = nullptr;
96 }
97 },
98 (void *)asynccallbackinfo,
99 &asynccallbackinfo->asyncWork);
100
101 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
102 if (asynccallbackinfo->info.isCallback) {
103 return Common::NapiGetNull(env);
104 } else {
105 return promise;
106 }
107 }
108
NapiUnsubscribe(napi_env env,napi_callback_info info)109 napi_value NapiUnsubscribe(napi_env env, napi_callback_info info)
110 {
111 ANS_LOGI("Unsubscribe start");
112 ParametersInfoUnsubscribe paras;
113 if (ParseParameters(env, info, paras) == nullptr) {
114 Common::NapiThrow(env, ERROR_PARAM_INVALID);
115 return Common::NapiGetUndefined(env);
116 }
117
118 AsyncCallbackInfoUnsubscribe *asynccallbackinfo = new (std::nothrow)
119 AsyncCallbackInfoUnsubscribe {.env = env, .asyncWork = nullptr, .objectInfo = paras.objectInfo};
120 if (!asynccallbackinfo) {
121 return Common::JSParaError(env, paras.callback);
122 }
123 napi_value promise = nullptr;
124 Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
125
126 napi_value resourceName = nullptr;
127 napi_create_string_latin1(env, "unsubscribe", NAPI_AUTO_LENGTH, &resourceName);
128
129 // Asynchronous function call
130 napi_create_async_work(env,
131 nullptr,
132 resourceName,
133 [](napi_env env, void *data) {
134 ANS_LOGI("Unsubscribe napi_create_async_work start");
135 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoUnsubscribe *>(data);
136 if (asynccallbackinfo) {
137 if (asynccallbackinfo->objectInfo == nullptr) {
138 ANS_LOGE("invalid object info");
139 asynccallbackinfo->info.errorCode = ERR_ANS_INVALID_PARAM;
140 return;
141 }
142
143 bool ret = AddDeletingSubscriber(asynccallbackinfo->objectInfo);
144 if (ret) {
145 asynccallbackinfo->info.errorCode =
146 NotificationHelper::UnSubscribeNotification(*(asynccallbackinfo->objectInfo));
147 if (asynccallbackinfo->info.errorCode != ERR_OK) {
148 DelDeletingSubscriber(asynccallbackinfo->objectInfo);
149 }
150 } else {
151 asynccallbackinfo->info.errorCode = ERR_ANS_SUBSCRIBER_IS_DELETING;
152 }
153 }
154 },
155 [](napi_env env, napi_status status, void *data) {
156 ANS_LOGI("Unsubscribe napi_create_async_work end");
157 AsyncCallbackInfoUnsubscribe *asynccallbackinfo = static_cast<AsyncCallbackInfoUnsubscribe *>(data);
158 if (asynccallbackinfo) {
159 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
160 if (asynccallbackinfo->info.callback != nullptr) {
161 napi_delete_reference(env, asynccallbackinfo->info.callback);
162 }
163 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
164 delete asynccallbackinfo;
165 asynccallbackinfo = nullptr;
166 }
167 },
168 (void *)asynccallbackinfo,
169 &asynccallbackinfo->asyncWork);
170
171 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
172 if (asynccallbackinfo->info.isCallback) {
173 return Common::NapiGetNull(env);
174 } else {
175 return promise;
176 }
177 }
178 } // namespace NotificationNapi
179 } // namespace OHOS