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_enable_notification.h"
17
18 #include "napi_base_context.h"
19
20 #include "ans_dialog_host_client.h"
21 #include "ans_inner_errors.h"
22 #include "enable_notification.h"
23 #include "js_ans_dialog_callback.h"
24 #include "common_event_manager.h"
25
26 namespace OHOS {
27 namespace NotificationNapi {
28 const int IS_NOTIFICATION_ENABLE_MAX_PARA = 2;
AsyncCompleteCallbackNapiEnableNotification(napi_env env,napi_status status,void * data)29 void AsyncCompleteCallbackNapiEnableNotification(napi_env env, napi_status status, void *data)
30 {
31 ANS_LOGD("called");
32 if (!data) {
33 ANS_LOGE("Invalid async callback data");
34 return;
35 }
36 AsyncCallbackInfoEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoEnable *>(data);
37 if (asynccallbackinfo) {
38 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
39 if (asynccallbackinfo->info.callback != nullptr) {
40 ANS_LOGD("Delete napiEnableNotification callback reference.");
41 napi_delete_reference(env, asynccallbackinfo->info.callback);
42 }
43 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
44 delete asynccallbackinfo;
45 asynccallbackinfo = nullptr;
46 }
47 }
48
NapiEnableNotification(napi_env env,napi_callback_info info)49 napi_value NapiEnableNotification(napi_env env, napi_callback_info info)
50 {
51 ANS_LOGD("called");
52 EnableParams params {};
53 if (ParseParameters(env, info, params) == nullptr) {
54 Common::NapiThrow(env, ERROR_PARAM_INVALID);
55 return Common::NapiGetUndefined(env);
56 }
57
58 AsyncCallbackInfoEnable *asynccallbackinfo =
59 new (std::nothrow) AsyncCallbackInfoEnable {.env = env, .asyncWork = nullptr, .params = params};
60 if (!asynccallbackinfo) {
61 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
62 return Common::JSParaError(env, params.callback);
63 }
64 napi_value promise = nullptr;
65 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
66
67 napi_value resourceName = nullptr;
68 napi_create_string_latin1(env, "enableNotification", NAPI_AUTO_LENGTH, &resourceName);
69 // Asynchronous function call
70 napi_create_async_work(env,
71 nullptr,
72 resourceName,
73 [](napi_env env, void *data) {
74 ANS_LOGD("NapiEnableNotification work excute.");
75 AsyncCallbackInfoEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoEnable *>(data);
76 if (asynccallbackinfo) {
77 std::string deviceId {""};
78 asynccallbackinfo->info.errorCode = NotificationHelper::SetNotificationsEnabledForSpecifiedBundle(
79 asynccallbackinfo->params.option, deviceId, asynccallbackinfo->params.enable);
80 ANS_LOGI("errorCode = %{public}d", asynccallbackinfo->info.errorCode);
81 }
82 },
83 AsyncCompleteCallbackNapiEnableNotification,
84 (void *)asynccallbackinfo,
85 &asynccallbackinfo->asyncWork);
86
87 bool isCallback = asynccallbackinfo->info.isCallback;
88 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
89
90 if (isCallback) {
91 ANS_LOGD("null isCallback");
92 return Common::NapiGetNull(env);
93 } else {
94 return promise;
95 }
96 }
97
AsyncCompleteCallbackNapiIsNotificationEnabled(napi_env env,napi_status status,void * data)98 void AsyncCompleteCallbackNapiIsNotificationEnabled(napi_env env, napi_status status, void *data)
99 {
100 ANS_LOGD("called");
101 if (!data) {
102 ANS_LOGE("Invalid async callback data");
103 return;
104 }
105 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
106 if (asynccallbackinfo) {
107 napi_value result = nullptr;
108 napi_get_boolean(env, asynccallbackinfo->allowed, &result);
109 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
110 if (asynccallbackinfo->info.callback != nullptr) {
111 napi_delete_reference(env, asynccallbackinfo->info.callback);
112 }
113 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
114 delete asynccallbackinfo;
115 asynccallbackinfo = nullptr;
116 }
117 }
118
NapiIsNotificationEnabled(napi_env env,napi_callback_info info)119 __attribute__((no_sanitize("cfi"))) napi_value NapiIsNotificationEnabled(napi_env env, napi_callback_info info)
120 {
121 ANS_LOGD("called");
122 IsEnableParams params {};
123 if (ParseParameters(env, info, params) == nullptr) {
124 ANS_LOGD("null ParseParameters");
125 Common::NapiThrow(env, ERROR_PARAM_INVALID);
126 return Common::NapiGetUndefined(env);
127 }
128
129 AsyncCallbackInfoIsEnable *asynccallbackinfo =
130 new (std::nothrow) AsyncCallbackInfoIsEnable {.env = env, .asyncWork = nullptr, .params = params};
131 if (!asynccallbackinfo) {
132 ANS_LOGD("null asynccallbackinfo");
133 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
134 return Common::JSParaError(env, params.callback);
135 }
136 napi_value promise = nullptr;
137 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
138
139 napi_value resourceName = nullptr;
140 napi_create_string_latin1(env, "isNotificationEnabled", NAPI_AUTO_LENGTH, &resourceName);
141 // Asynchronous function call
142 napi_create_async_work(env,
143 nullptr,
144 resourceName,
145 [](napi_env env, void *data) {
146 ANS_LOGD("NapiIsNotificationEnabled work excute.");
147 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
148 if (asynccallbackinfo) {
149 if (asynccallbackinfo->params.hasBundleOption) {
150 ANS_LOGI("option.bundle : %{public}s option.uid : %{public}d",
151 asynccallbackinfo->params.option.GetBundleName().c_str(),
152 asynccallbackinfo->params.option.GetUid());
153 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(
154 asynccallbackinfo->params.option, asynccallbackinfo->allowed);
155 } else if (asynccallbackinfo->params.hasUserId) {
156 ANS_LOGI("userId:%{public}d", asynccallbackinfo->params.userId);
157 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(
158 asynccallbackinfo->params.userId, asynccallbackinfo->allowed);
159 } else {
160 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotifySelf(
161 asynccallbackinfo->allowed);
162 }
163 ANS_LOGI("errorCode:%{public}d, allowed:%{public}d",
164 asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
165 }
166 },
167 AsyncCompleteCallbackNapiIsNotificationEnabled,
168 (void *)asynccallbackinfo,
169 &asynccallbackinfo->asyncWork);
170
171 bool isCallback = asynccallbackinfo->info.isCallback;
172 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
173
174 if (isCallback) {
175 ANS_LOGD("null isCallback");
176 return Common::NapiGetNull(env);
177 } else {
178 return promise;
179 }
180 }
181
NapiIsNotificationEnabledSelf(napi_env env,napi_callback_info info)182 napi_value NapiIsNotificationEnabledSelf(napi_env env, napi_callback_info info)
183 {
184 ANS_LOGD("called");
185 IsEnableParams params {};
186 if (ParseParameters(env, info, params) == nullptr) {
187 Common::NapiThrow(env, ERROR_PARAM_INVALID);
188 return Common::NapiGetUndefined(env);
189 }
190
191 AsyncCallbackInfoIsEnable *asynccallbackinfo =
192 new (std::nothrow) AsyncCallbackInfoIsEnable {.env = env, .asyncWork = nullptr, .params = params};
193 if (!asynccallbackinfo) {
194 ANS_LOGD("null asynccallbackinfo");
195 return Common::JSParaError(env, params.callback);
196 }
197 napi_value promise = nullptr;
198 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
199
200 napi_value resourceName = nullptr;
201 napi_create_string_latin1(env, "IsNotificationEnabledSelf", NAPI_AUTO_LENGTH, &resourceName);
202 // Asynchronous function call
203 napi_create_async_work(env,
204 nullptr,
205 resourceName,
206 [](napi_env env, void *data) {
207 ANS_LOGD("NapiIsNotificationEnabledSelf work excute.");
208 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
209 if (asynccallbackinfo) {
210 if (asynccallbackinfo->params.hasBundleOption) {
211 ANS_LOGE("Not allowed to query another application");
212 } else {
213 asynccallbackinfo->info.errorCode =
214 NotificationHelper::IsAllowedNotifySelf(asynccallbackinfo->allowed);
215 }
216 ANS_LOGD("errorCode: %{public}d, allowed:%{public}d",
217 asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
218 }
219 },
220 AsyncCompleteCallbackNapiIsNotificationEnabled,
221 (void *)asynccallbackinfo,
222 &asynccallbackinfo->asyncWork);
223
224 bool isCallback = asynccallbackinfo->info.isCallback;
225 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
226
227 if (isCallback) {
228 ANS_LOGD("null isCallback");
229 return Common::NapiGetNull(env);
230 } else {
231 return promise;
232 }
233 }
234
NapiAsyncCompleteCallbackRequestEnableNotification(napi_env env,void * data)235 void NapiAsyncCompleteCallbackRequestEnableNotification(napi_env env, void *data)
236 {
237 ANS_LOGD("called");
238 if (data == nullptr) {
239 ANS_LOGE("null data");
240 return;
241 }
242 auto* asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable*>(data);
243 napi_value result = nullptr;
244 napi_get_undefined(env, &result);
245 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
246 if (asynccallbackinfo->info.callback != nullptr) {
247 napi_delete_reference(env, asynccallbackinfo->info.callback);
248 }
249 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
250 delete asynccallbackinfo;
251 }
252
NapiRequestEnableNotification(napi_env env,napi_callback_info info)253 napi_value NapiRequestEnableNotification(napi_env env, napi_callback_info info)
254 {
255 ANS_LOGD("called");
256 IsEnableParams params {};
257 if (ParseRequestEnableParameters(env, info, params) == nullptr) {
258 Common::NapiThrow(env, ERROR_PARAM_INVALID);
259 return Common::NapiGetUndefined(env);
260 }
261
262 AsyncCallbackInfoIsEnable *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoIsEnable {
263 .env = env, .params = params, .newInterface = true};
264 if (!asynccallbackinfo) {
265 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
266 return Common::JSParaError(env, params.callback);
267 }
268 napi_value promise = nullptr;
269 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
270
271 napi_value resourceName = nullptr;
272 napi_create_string_latin1(env, "RequestEnableNotification", NAPI_AUTO_LENGTH, &resourceName);
273
274 auto ipcCall = [](napi_env env, void* data) {
275 ANS_LOGD("called");
276 if (data == nullptr) {
277 ANS_LOGE("null data");
278 return;
279 }
280 auto* asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable*>(data);
281 sptr<AnsDialogHostClient> client = nullptr;
282 AnsDialogHostClient::CreateIfNullptr(client, true);
283 if (client == nullptr) {
284 ANS_LOGE("create client fail");
285 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
286 return;
287 }
288
289 if (asynccallbackinfo->params.context != nullptr) {
290 ANS_LOGD("stage mode");
291 bool canPop = false;
292 std::string bundleName {""};
293 ErrCode errCode = NotificationHelper::CanPopEnableNotificationDialog(client, canPop, bundleName);
294 ANS_LOGI("errCode:%{public}d, canPop:%{public}d", errCode, canPop);
295 if (canPop == false) {
296 asynccallbackinfo->info.errorCode = errCode;
297 return;
298 }
299 asynccallbackinfo->bundleName = bundleName;
300 } else {
301 ANS_LOGD("un stage mode");
302 std::string deviceId {""};
303 asynccallbackinfo->info.errorCode =
304 NotificationHelper::RequestEnableNotification(deviceId, client,
305 asynccallbackinfo->params.callerToken);
306 }
307 ANS_LOGI("errorCode: %{public}d", asynccallbackinfo->info.errorCode);
308 };
309 auto jsCb = [](napi_env env, napi_status status, void* data) {
310 ANS_LOGD("called");
311 if (data == nullptr) {
312 ANS_LOGE("null data");
313 return;
314 }
315 auto* asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable*>(data);
316 if (!asynccallbackinfo->bundleName.empty()) {
317 bool success = CreateUIExtension(asynccallbackinfo->params.context, asynccallbackinfo->bundleName);
318 if (success) {
319 asynccallbackinfo->info.errorCode = ERR_ANS_DIALOG_POP_SUCCEEDED;
320 } else {
321 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
322 NotificationHelper::RemoveEnableNotificationDialog();
323 }
324 }
325 ErrCode errCode = asynccallbackinfo->info.errorCode;
326 if (errCode != ERR_ANS_DIALOG_POP_SUCCEEDED) {
327 ANS_LOGE("errCode: %{public}d", errCode);
328 NapiAsyncCompleteCallbackRequestEnableNotification(env, static_cast<void*>(asynccallbackinfo));
329 return;
330 }
331 // Dialog is popped
332 auto jsCallback = std::make_unique<JsAnsDialogCallback>();
333 if (!jsCallback->Init(env, asynccallbackinfo, NapiAsyncCompleteCallbackRequestEnableNotification) ||
334 !AnsDialogHostClient::SetDialogCallbackInterface(std::move(jsCallback))
335 ) {
336 ANS_LOGE("error");
337 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
338 NapiAsyncCompleteCallbackRequestEnableNotification(env, static_cast<void*>(asynccallbackinfo));
339 return;
340 }
341 };
342
343 // Asynchronous function call
344 napi_create_async_work(env,
345 nullptr,
346 resourceName,
347 ipcCall,
348 jsCb,
349 static_cast<void*>(asynccallbackinfo),
350 &asynccallbackinfo->asyncWork);
351
352 bool isCallback = asynccallbackinfo->info.isCallback;
353 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
354
355 if (isCallback) {
356 ANS_LOGD("null isCallback");
357 return Common::NapiGetNull(env);
358 } else {
359 return promise;
360 }
361 }
362
ParseRequestEnableParameters(const napi_env & env,const napi_callback_info & info,IsEnableParams & params)363 napi_value ParseRequestEnableParameters(const napi_env &env, const napi_callback_info &info, IsEnableParams ¶ms)
364 {
365 ANS_LOGD("called");
366
367 size_t argc = IS_NOTIFICATION_ENABLE_MAX_PARA;
368 napi_value argv[IS_NOTIFICATION_ENABLE_MAX_PARA] = {nullptr};
369 napi_value thisVar = nullptr;
370 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
371
372 if (argc == 0) {
373 return Common::NapiGetNull(env);
374 }
375
376 // argv[0]: context / callback
377 napi_valuetype valuetype = napi_undefined;
378 NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
379 if ((valuetype != napi_object) && (valuetype != napi_function)) {
380 ANS_LOGW("Wrong argument type. Function or object expected. Excute promise.");
381 return Common::NapiGetNull(env);
382 }
383 if (valuetype == napi_object) {
384 bool stageMode = false;
385 napi_status status = OHOS::AbilityRuntime::IsStageContext(env, argv[PARAM0], stageMode);
386 if (status == napi_ok && stageMode) {
387 SetEnableParam(params, env, argv[PARAM0]);
388 } else {
389 ANS_LOGE("Only support stage mode");
390 std::string msg = "Incorrect parameter types.Only support stage mode.";
391 Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
392 return nullptr;
393 }
394 } else {
395 napi_create_reference(env, argv[PARAM0], 1, ¶ms.callback);
396 }
397 // argv[1]:context
398 if (argc >= IS_NOTIFICATION_ENABLE_MAX_PARA && valuetype == napi_object) {
399 NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
400 if (valuetype != napi_function) {
401 ANS_LOGW("Callback is not function excute promise.");
402 return Common::NapiGetNull(env);
403 }
404 napi_create_reference(env, argv[PARAM1], 1, ¶ms.callback);
405 }
406
407 return Common::NapiGetNull(env);
408 }
409
AsyncCompleteCallbackNapiGetAllNotificationEnableStatus(napi_env env,napi_status status,void * data)410 void AsyncCompleteCallbackNapiGetAllNotificationEnableStatus(napi_env env, napi_status status, void *data)
411 {
412 ANS_LOGD("called");
413 if (!data) {
414 ANS_LOGE("Invalid async callback data");
415 return;
416 }
417 napi_value result = nullptr;
418 AsyncCallbackInfoEnableStatus *asynccallbackinfo = static_cast<AsyncCallbackInfoEnableStatus *>(data);
419 if (asynccallbackinfo == nullptr) {
420 ANS_LOGE("null asynccallbackinfo");
421 return;
422 }
423 if (asynccallbackinfo->info.errorCode != ERR_OK) {
424 result = Common::NapiGetNull(env);
425 }
426 napi_value arr = nullptr;
427 napi_create_array(env, &arr);
428 size_t count = 0;
429 for (auto vec : asynccallbackinfo->bundleOptionVector) {
430 napi_value nSlot = nullptr;
431 napi_create_object(env, &nSlot);
432 Common::SetNotificationEnableStatus(env, vec, nSlot);
433 napi_set_element(env, arr, count, nSlot);
434 count++;
435 }
436 result = arr;
437 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
438 if (asynccallbackinfo->info.callback != nullptr) {
439 ANS_LOGD("Delete napiGetSlots callback reference.");
440 napi_delete_reference(env, asynccallbackinfo->info.callback);
441 }
442 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
443 delete asynccallbackinfo;
444 asynccallbackinfo = nullptr;
445 }
446
NapiGetAllNotificationEnabledBundles(napi_env env,napi_callback_info info)447 napi_value NapiGetAllNotificationEnabledBundles(napi_env env, napi_callback_info info)
448 {
449 ANS_LOGD("called");
450 napi_ref callback = nullptr;
451 AsyncCallbackInfoEnableStatus *asynccallbackinfo =
452 new (std::nothrow) AsyncCallbackInfoEnableStatus{ .env = env, .asyncWork = nullptr };
453 if (asynccallbackinfo == nullptr) {
454 ANS_LOGE("null asynccallbackinfo");
455 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
456 return Common::NapiGetUndefined(env);
457 }
458 napi_value promise = nullptr;
459 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
460 napi_value resourceName = nullptr;
461 napi_create_string_latin1(env, "getAllNotificationEnabledBundles", NAPI_AUTO_LENGTH, &resourceName);
462 napi_create_async_work(
463 env, nullptr, resourceName,
464 [](napi_env env, void *data) {
465 AsyncCallbackInfoEnableStatus *asynccallbackinfo = static_cast<AsyncCallbackInfoEnableStatus *>(data);
466 if (asynccallbackinfo != nullptr) {
467 asynccallbackinfo->info.errorCode =
468 NotificationHelper::GetAllNotificationEnabledBundles(asynccallbackinfo->bundleOptionVector);
469 ANS_LOGD("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
470 }
471 },
472 AsyncCompleteCallbackNapiGetAllNotificationEnableStatus, (void *)asynccallbackinfo,
473 &asynccallbackinfo->asyncWork);
474 bool isCallback = asynccallbackinfo->info.isCallback;
475 napi_status status = napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
476 if (status != napi_ok) {
477 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
478 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
479 if (asynccallbackinfo->info.callback != nullptr) {
480 ANS_LOGD("Delete callback reference.");
481 napi_delete_reference(env, asynccallbackinfo->info.callback);
482 }
483 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
484 delete asynccallbackinfo;
485 asynccallbackinfo = nullptr;
486 }
487
488 if (isCallback) {
489 ANS_LOGD("null isCallback");
490 return Common::NapiGetNull(env);
491 } else {
492 return promise;
493 }
494 }
495
NapiIsNotificationEnabledSync(napi_env env,napi_callback_info info)496 napi_value NapiIsNotificationEnabledSync(napi_env env, napi_callback_info info)
497 {
498 ANS_LOGD("called");
499 IsEnableParams params {};
500 if (ParseParameters(env, info, params) == nullptr) {
501 ANS_LOGD("null ParseParameters");
502 Common::NapiThrow(env, ERROR_PARAM_INVALID);
503 return Common::NapiGetUndefined(env);
504 }
505
506 bool allowed = false;
507 NotificationHelper::IsAllowedNotifySelf(allowed);
508 napi_value result = nullptr;
509 napi_get_boolean(env, allowed, &result);
510 return result;
511 }
512
CreateUIExtension(std::shared_ptr<OHOS::AbilityRuntime::Context> context,std::string & bundleName)513 bool CreateUIExtension(std::shared_ptr<OHOS::AbilityRuntime::Context> context, std::string &bundleName)
514 {
515 if (context == nullptr) {
516 ANS_LOGE("null context");
517 return false;
518 }
519
520 std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext =
521 OHOS::AbilityRuntime::Context::ConvertTo<OHOS::AbilityRuntime::AbilityContext>(context);
522 if (abilityContext == nullptr) {
523 ANS_LOGE("null abilityContext");
524 return false;
525 }
526 auto uiContent = abilityContext->GetUIContent();
527 if (uiContent == nullptr) {
528 ANS_LOGE("null uiContent");
529 return false;
530 }
531
532 AAFwk::Want want;
533 std::string targetBundleName = "com.ohos.notificationdialog";
534 std::string targetAbilityName = "EnableNotificationDialog";
535 want.SetElementName(targetBundleName, targetAbilityName);
536
537 std::string typeKey = "ability.want.params.uiExtensionType";
538 std::string typeValue = "sysDialog/common";
539 want.SetParam(typeKey, typeValue);
540
541 auto uiExtCallback = std::make_shared<ModalExtensionCallback>();
542 uiExtCallback->SetAbilityContext(abilityContext);
543 uiExtCallback->SetBundleName(bundleName);
544 Ace::ModalUIExtensionCallbacks uiExtensionCallbacks = {
545 .onRelease = std::bind(&ModalExtensionCallback::OnRelease, uiExtCallback, std::placeholders::_1),
546 .onResult = std::bind(&ModalExtensionCallback::OnResult, uiExtCallback,
547 std::placeholders::_1, std::placeholders::_2),
548 .onReceive = std::bind(&ModalExtensionCallback::OnReceive, uiExtCallback, std::placeholders::_1),
549 .onError = std::bind(&ModalExtensionCallback::OnError, uiExtCallback,
550 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
551 .onRemoteReady = std::bind(&ModalExtensionCallback::OnRemoteReady, uiExtCallback, std::placeholders::_1),
552 .onDestroy = std::bind(&ModalExtensionCallback::OnDestroy, uiExtCallback),
553 };
554
555 Ace::ModalUIExtensionConfig config;
556 config.isProhibitBack = true;
557
558 int32_t sessionId = uiContent->CreateModalUIExtension(want, uiExtensionCallbacks, config);
559 ANS_LOGI("sessionId: %{public}d", sessionId);
560 if (sessionId == 0) {
561 ANS_LOGE("Create component failed, sessionId is 0");
562 return false;
563 }
564 uiExtCallback->SetSessionId(sessionId);
565 return true;
566 }
567
SetEnableParam(IsEnableParams & params,const napi_env & env,napi_value & object)568 void SetEnableParam(IsEnableParams ¶ms, const napi_env &env, napi_value &object)
569 {
570 auto context = OHOS::AbilityRuntime::GetStageModeContext(env, object);
571 sptr<IRemoteObject> callerToken = nullptr;
572 if (context != nullptr) {
573 callerToken = context->GetToken();
574 }
575 params.context = context;
576 params.callerToken = callerToken;
577 params.hasCallerToken = true;
578 }
579
ModalExtensionCallback()580 ModalExtensionCallback::ModalExtensionCallback()
581 {}
582
~ModalExtensionCallback()583 ModalExtensionCallback::~ModalExtensionCallback()
584 {}
585
586
587 /*
588 * when UIExtensionAbility use terminateSelfWithResult
589 */
OnResult(int32_t resultCode,const AAFwk::Want & result)590 void ModalExtensionCallback::OnResult(int32_t resultCode, const AAFwk::Want& result)
591 {
592 ANS_LOGD("called");
593 }
594
595 /*
596 * when UIExtensionAbility send message to UIExtensionComponent
597 */
OnReceive(const AAFwk::WantParams & receive)598 void ModalExtensionCallback::OnReceive(const AAFwk::WantParams& receive)
599 {
600 ANS_LOGD("called");
601 }
602
603 /*
604 * when UIExtensionAbility disconnect or use terminate or process die
605 * releaseCode is 0 when process normal exit
606 */
OnRelease(int32_t releaseCode)607 void ModalExtensionCallback::OnRelease(int32_t releaseCode)
608 {
609 ANS_LOGI("called");
610 ReleaseOrErrorHandle(releaseCode);
611 }
612
613 /*
614 * when UIExtensionComponent init or turn to background or destroy UIExtensionAbility occur error
615 */
OnError(int32_t code,const std::string & name,const std::string & message)616 void ModalExtensionCallback::OnError(int32_t code, const std::string& name, const std::string& message)
617 {
618 ANS_LOGD("called, name = %{public}s, message = %{public}s", name.c_str(), message.c_str());
619 ReleaseOrErrorHandle(code);
620 NotificationHelper::RemoveEnableNotificationDialog();
621 }
622
623 /*
624 * when UIExtensionComponent connect to UIExtensionAbility, ModalUIExtensionProxy will init,
625 * UIExtensionComponent can send message to UIExtensionAbility by ModalUIExtensionProxy
626 */
OnRemoteReady(const std::shared_ptr<Ace::ModalUIExtensionProxy> & uiProxy)627 void ModalExtensionCallback::OnRemoteReady(const std::shared_ptr<Ace::ModalUIExtensionProxy>& uiProxy)
628 {
629 ANS_LOGD("called");
630 }
631
632 /*
633 * when UIExtensionComponent destructed
634 */
OnDestroy()635 void ModalExtensionCallback::OnDestroy()
636 {
637 ANS_LOGD("called");
638 }
639
640
SetSessionId(int32_t sessionId)641 void ModalExtensionCallback::SetSessionId(int32_t sessionId)
642 {
643 this->sessionId_ = sessionId;
644 }
645
SetBundleName(std::string bundleName)646 void ModalExtensionCallback::SetBundleName(std::string bundleName)
647 {
648 this->bundleName_ = bundleName;
649 }
650
SetAbilityContext(std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext)651 void ModalExtensionCallback::SetAbilityContext(std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext)
652 {
653 this->abilityContext_ = abilityContext;
654 }
655
ReleaseOrErrorHandle(int32_t code)656 void ModalExtensionCallback::ReleaseOrErrorHandle(int32_t code)
657 {
658 ANS_LOGD("start");
659 Ace::UIContent* uiContent = this->abilityContext_->GetUIContent();
660 if (uiContent == nullptr) {
661 ANS_LOGE("null uiContent");
662 return;
663 }
664 uiContent->CloseModalUIExtension(this->sessionId_);
665 ANS_LOGD("end");
666 return;
667 }
668
669 } // namespace NotificationNapi
670 } // namespace OHOS
671