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("enter");
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("enter");
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("asynccallbackinfo->info.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("napiEnableNotification callback is nullptr.");
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("enter");
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("enter");
122     IsEnableParams params {};
123     if (ParseParameters(env, info, params) == nullptr) {
124         ANS_LOGD("ParseParameters is nullptr.");
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("Asynccallbackinfo is nullptr.");
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("asynccallbackinfo->info.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("napiIsNotificationEnabled callback is nullptr.");
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("enter");
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("Asynccallbackinfo is null.");
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("asynccallbackinfo->info.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("napiIsNotificationEnabledSelf callback is nullptr.");
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("enter");
238     if (data == nullptr) {
239         ANS_LOGE("Invalid async callback 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_LOGI("NapiRequestEnableNotification enter");
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("enter");
276         if (data == nullptr) {
277             ANS_LOGE("data is invalid");
278             return;
279         }
280         auto* asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable*>(data);
281         sptr<AnsDialogHostClient> client = nullptr;
282         if (!AnsDialogHostClient::CreateIfNullptr(client)) {
283             asynccallbackinfo->info.errorCode = ERR_ANS_DIALOG_IS_POPPING;
284             return;
285         }
286 
287         if (asynccallbackinfo->params.context != nullptr) {
288             ANS_LOGD("stage mode");
289             bool canPop = false;
290             std::string bundleName {""};
291             ErrCode errCode = NotificationHelper::CanPopEnableNotificationDialog(client, canPop, bundleName);
292             ANS_LOGI("CanPopEnableNotificationDialog  result , errCode = %{public}d , canPop = %{public}d",
293                 errCode, canPop);
294             if (canPop == false) {
295                 asynccallbackinfo->info.errorCode = errCode;
296                 return;
297             }
298             bool success = CreateUIExtension(asynccallbackinfo->params.context, bundleName);
299             if (success) {
300                 asynccallbackinfo->info.errorCode = ERR_ANS_DIALOG_POP_SUCCEEDED;
301             } else {
302                 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
303                 NotificationHelper::RemoveEnableNotificationDialog();
304             }
305         } else {
306             ANS_LOGD("un stage mode");
307             std::string deviceId {""};
308             asynccallbackinfo->info.errorCode =
309             NotificationHelper::RequestEnableNotification(deviceId, client,
310                 asynccallbackinfo->params.callerToken);
311         }
312         ANS_LOGI("done, code is %{public}d.", asynccallbackinfo->info.errorCode);
313     };
314     auto jsCb = [](napi_env env, napi_status status, void* data) {
315         ANS_LOGD("enter");
316         if (data == nullptr) {
317             AnsDialogHostClient::Destroy();
318             return;
319         }
320         auto* asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable*>(data);
321         ErrCode errCode = asynccallbackinfo->info.errorCode;
322         if (errCode != ERR_ANS_DIALOG_POP_SUCCEEDED) {
323             ANS_LOGE("error, code is %{public}d.", errCode);
324             AnsDialogHostClient::Destroy();
325             NapiAsyncCompleteCallbackRequestEnableNotification(env, static_cast<void*>(asynccallbackinfo));
326             return;
327         }
328         // Dialog is popped
329         auto jsCallback = std::make_unique<JsAnsDialogCallback>();
330         if (!jsCallback->Init(env, asynccallbackinfo, NapiAsyncCompleteCallbackRequestEnableNotification) ||
331             !AnsDialogHostClient::SetDialogCallbackInterface(std::move(jsCallback))
332         ) {
333             ANS_LOGE("error");
334             asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
335             AnsDialogHostClient::Destroy();
336             NapiAsyncCompleteCallbackRequestEnableNotification(env, static_cast<void*>(asynccallbackinfo));
337             return;
338         }
339     };
340 
341     // Asynchronous function call
342     napi_create_async_work(env,
343         nullptr,
344         resourceName,
345         ipcCall,
346         jsCb,
347         static_cast<void*>(asynccallbackinfo),
348         &asynccallbackinfo->asyncWork);
349 
350     bool isCallback = asynccallbackinfo->info.isCallback;
351     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
352 
353     if (isCallback) {
354         ANS_LOGD("napiRequestEnableNotification callback is nullptr.");
355         return Common::NapiGetNull(env);
356     } else {
357         return promise;
358     }
359 }
360 
ParseRequestEnableParameters(const napi_env & env,const napi_callback_info & info,IsEnableParams & params)361 napi_value ParseRequestEnableParameters(const napi_env &env, const napi_callback_info &info, IsEnableParams &params)
362 {
363     ANS_LOGD("enter");
364 
365     size_t argc = IS_NOTIFICATION_ENABLE_MAX_PARA;
366     napi_value argv[IS_NOTIFICATION_ENABLE_MAX_PARA] = {nullptr};
367     napi_value thisVar = nullptr;
368     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
369 
370     if (argc == 0) {
371         return Common::NapiGetNull(env);
372     }
373 
374     // argv[0]: context / callback
375     napi_valuetype valuetype = napi_undefined;
376     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
377     if ((valuetype != napi_object) && (valuetype != napi_function)) {
378         ANS_LOGW("Wrong argument type. Function or object expected. Excute promise.");
379         return Common::NapiGetNull(env);
380     }
381     if (valuetype == napi_object) {
382         bool stageMode = false;
383         napi_status status = OHOS::AbilityRuntime::IsStageContext(env, argv[PARAM0], stageMode);
384         if (status == napi_ok && stageMode) {
385             SetEnableParam(params, env, argv[PARAM0]);
386         } else {
387             ANS_LOGE("Only support stage mode");
388             std::string msg = "Incorrect parameter types.Only support stage mode.";
389             Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
390             return nullptr;
391         }
392     } else {
393         napi_create_reference(env, argv[PARAM0], 1, &params.callback);
394     }
395     // argv[1]:context
396     if (argc >= IS_NOTIFICATION_ENABLE_MAX_PARA && valuetype == napi_object) {
397         NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
398         if (valuetype != napi_function) {
399             ANS_LOGW("Callback is not function excute promise.");
400             return Common::NapiGetNull(env);
401         }
402         napi_create_reference(env, argv[PARAM1], 1, &params.callback);
403     }
404 
405     return Common::NapiGetNull(env);
406 }
407 
AsyncCompleteCallbackNapiGetAllNotificationEnableStatus(napi_env env,napi_status status,void * data)408 void AsyncCompleteCallbackNapiGetAllNotificationEnableStatus(napi_env env, napi_status status, void *data)
409 {
410     ANS_LOGD("Called.");
411     if (!data) {
412         ANS_LOGE("Invalid async callback data");
413         return;
414     }
415     napi_value result = nullptr;
416     AsyncCallbackInfoEnableStatus *asynccallbackinfo = static_cast<AsyncCallbackInfoEnableStatus *>(data);
417     if (asynccallbackinfo == nullptr) {
418         ANS_LOGE("asynccallbackinfo is nullptr");
419         return;
420     }
421     if (asynccallbackinfo->info.errorCode != ERR_OK) {
422         result = Common::NapiGetNull(env);
423     }
424     napi_value arr = nullptr;
425     napi_create_array(env, &arr);
426     size_t count = 0;
427     for (auto vec : asynccallbackinfo->bundleOptionVector) {
428         napi_value nSlot = nullptr;
429         napi_create_object(env, &nSlot);
430         Common::SetNotificationEnableStatus(env, vec, nSlot);
431         napi_set_element(env, arr, count, nSlot);
432         count++;
433     }
434     result = arr;
435     Common::CreateReturnValue(env, asynccallbackinfo->info, result);
436     if (asynccallbackinfo->info.callback != nullptr) {
437         ANS_LOGD("Delete napiGetSlots callback reference.");
438         napi_delete_reference(env, asynccallbackinfo->info.callback);
439     }
440     napi_delete_async_work(env, asynccallbackinfo->asyncWork);
441     delete asynccallbackinfo;
442     asynccallbackinfo = nullptr;
443 }
444 
NapiGetAllNotificationEnabledBundles(napi_env env,napi_callback_info info)445 napi_value NapiGetAllNotificationEnabledBundles(napi_env env, napi_callback_info info)
446 {
447     ANS_LOGD("Called");
448     napi_ref callback = nullptr;
449     AsyncCallbackInfoEnableStatus *asynccallbackinfo =
450         new (std::nothrow) AsyncCallbackInfoEnableStatus{ .env = env, .asyncWork = nullptr };
451     if (asynccallbackinfo == nullptr) {
452         ANS_LOGE("asynccallbackinfo is nullptr");
453         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
454         return Common::NapiGetUndefined(env);
455     }
456     napi_value promise = nullptr;
457     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
458     napi_value resourceName = nullptr;
459     napi_create_string_latin1(env, "getAllNotificationEnabledBundles", NAPI_AUTO_LENGTH, &resourceName);
460     napi_create_async_work(
461         env, nullptr, resourceName,
462         [](napi_env env, void *data) {
463             AsyncCallbackInfoEnableStatus *asynccallbackinfo = static_cast<AsyncCallbackInfoEnableStatus *>(data);
464             if (asynccallbackinfo != nullptr) {
465                 asynccallbackinfo->info.errorCode =
466                     NotificationHelper::GetAllNotificationEnabledBundles(asynccallbackinfo->bundleOptionVector);
467                 ANS_LOGD("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
468             }
469         },
470         AsyncCompleteCallbackNapiGetAllNotificationEnableStatus, (void *)asynccallbackinfo,
471         &asynccallbackinfo->asyncWork);
472     bool isCallback = asynccallbackinfo->info.isCallback;
473     napi_status status = napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
474     if (status != napi_ok) {
475         asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
476         Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
477         if (asynccallbackinfo->info.callback != nullptr) {
478             ANS_LOGD("Delete callback reference.");
479             napi_delete_reference(env, asynccallbackinfo->info.callback);
480         }
481         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
482         delete asynccallbackinfo;
483         asynccallbackinfo = nullptr;
484     }
485 
486     if (isCallback) {
487         ANS_LOGD("Callback is nullptr.");
488         return Common::NapiGetNull(env);
489     } else {
490         return promise;
491     }
492 }
493 
NapiIsNotificationEnabledSync(napi_env env,napi_callback_info info)494 napi_value NapiIsNotificationEnabledSync(napi_env env, napi_callback_info info)
495 {
496     ANS_LOGD("enter");
497     IsEnableParams params {};
498     if (ParseParameters(env, info, params) == nullptr) {
499         ANS_LOGD("ParseParameters is nullptr.");
500         Common::NapiThrow(env, ERROR_PARAM_INVALID);
501         return Common::NapiGetUndefined(env);
502     }
503 
504     bool allowed = false;
505     NotificationHelper::IsAllowedNotifySelf(allowed);
506     napi_value result = nullptr;
507     napi_get_boolean(env, allowed, &result);
508     return result;
509 }
510 
CreateUIExtension(std::shared_ptr<OHOS::AbilityRuntime::Context> context,std::string & bundleName)511 bool CreateUIExtension(std::shared_ptr<OHOS::AbilityRuntime::Context> context, std::string &bundleName)
512 {
513     if (context == nullptr) {
514         ANS_LOGE("Get context failed");
515         return false;
516     }
517 
518     std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext =
519         OHOS::AbilityRuntime::Context::ConvertTo<OHOS::AbilityRuntime::AbilityContext>(context);
520     if (abilityContext == nullptr) {
521         ANS_LOGE("abilityContext is null");
522         return false;
523     }
524     auto uiContent = abilityContext->GetUIContent();
525     if (uiContent == nullptr) {
526         ANS_LOGE("uiContent is null");
527         return false;
528     }
529 
530     AAFwk::Want want;
531     std::string targetBundleName = "com.ohos.notificationdialog";
532     std::string targetAbilityName = "EnableNotificationDialog";
533     want.SetElementName(targetBundleName, targetAbilityName);
534 
535     std::string typeKey = "ability.want.params.uiExtensionType";
536     std::string typeValue = "sysDialog/common";
537     want.SetParam(typeKey, typeValue);
538 
539     auto uiExtCallback = std::make_shared<ModalExtensionCallback>();
540     uiExtCallback->SetAbilityContext(abilityContext);
541     uiExtCallback->SetBundleName(bundleName);
542     Ace::ModalUIExtensionCallbacks uiExtensionCallbacks = {
543         .onRelease = std::bind(&ModalExtensionCallback::OnRelease, uiExtCallback, std::placeholders::_1),
544         .onResult = std::bind(&ModalExtensionCallback::OnResult, uiExtCallback,
545             std::placeholders::_1, std::placeholders::_2),
546         .onReceive = std::bind(&ModalExtensionCallback::OnReceive, uiExtCallback, std::placeholders::_1),
547         .onError = std::bind(&ModalExtensionCallback::OnError, uiExtCallback,
548             std::placeholders::_1, std::placeholders::_2, std::placeholders::_3),
549         .onRemoteReady = std::bind(&ModalExtensionCallback::OnRemoteReady, uiExtCallback, std::placeholders::_1),
550         .onDestroy = std::bind(&ModalExtensionCallback::OnDestroy, uiExtCallback),
551     };
552 
553     Ace::ModalUIExtensionConfig config;
554     config.isProhibitBack = true;
555 
556     int32_t sessionId = uiContent->CreateModalUIExtension(want, uiExtensionCallbacks, config);
557     ANS_LOGI("Create end, sessionId: %{public}d", sessionId);
558     if (sessionId == 0) {
559         ANS_LOGE("Create component failed, sessionId is 0");
560         return false;
561     }
562     uiExtCallback->SetSessionId(sessionId);
563     return true;
564 }
565 
SetEnableParam(IsEnableParams & params,const napi_env & env,napi_value & object)566 void SetEnableParam(IsEnableParams &params, const napi_env &env, napi_value &object)
567 {
568     auto context = OHOS::AbilityRuntime::GetStageModeContext(env, object);
569     sptr<IRemoteObject> callerToken = nullptr;
570     if (context != nullptr) {
571         callerToken = context->GetToken();
572     }
573     params.context = context;
574     params.callerToken = callerToken;
575     params.hasCallerToken = true;
576 }
577 
ModalExtensionCallback()578 ModalExtensionCallback::ModalExtensionCallback()
579 {}
580 
~ModalExtensionCallback()581 ModalExtensionCallback::~ModalExtensionCallback()
582 {}
583 
584 
585 /*
586  * when UIExtensionAbility use terminateSelfWithResult
587  */
OnResult(int32_t resultCode,const AAFwk::Want & result)588 void ModalExtensionCallback::OnResult(int32_t resultCode, const AAFwk::Want& result)
589 {
590     ANS_LOGD("OnResult");
591 }
592 
593 /*
594  * when UIExtensionAbility send message to UIExtensionComponent
595  */
OnReceive(const AAFwk::WantParams & receive)596 void ModalExtensionCallback::OnReceive(const AAFwk::WantParams& receive)
597 {
598     ANS_LOGD("OnReceive");
599 }
600 
601 /*
602  * when UIExtensionAbility disconnect or use terminate or process die
603  * releaseCode is 0 when process normal exit
604  */
OnRelease(int32_t releaseCode)605 void ModalExtensionCallback::OnRelease(int32_t releaseCode)
606 {
607     ANS_LOGI("OnRelease");
608     ReleaseOrErrorHandle(releaseCode);
609 }
610 
611 /*
612  * when UIExtensionComponent init or turn to background or destroy UIExtensionAbility occur error
613  */
OnError(int32_t code,const std::string & name,const std::string & message)614 void ModalExtensionCallback::OnError(int32_t code, const std::string& name, const std::string& message)
615 {
616     ANS_LOGE("OnError, name = %{public}s, message = %{public}s", name.c_str(), message.c_str());
617     ReleaseOrErrorHandle(code);
618     NotificationHelper::RemoveEnableNotificationDialog();
619 }
620 
621 /*
622  * when UIExtensionComponent connect to UIExtensionAbility, ModalUIExtensionProxy will init,
623  * UIExtensionComponent can send message to UIExtensionAbility by ModalUIExtensionProxy
624  */
OnRemoteReady(const std::shared_ptr<Ace::ModalUIExtensionProxy> & uiProxy)625 void ModalExtensionCallback::OnRemoteReady(const std::shared_ptr<Ace::ModalUIExtensionProxy>& uiProxy)
626 {
627     ANS_LOGD("OnRemoteReady");
628 }
629 
630 /*
631  * when UIExtensionComponent destructed
632  */
OnDestroy()633 void ModalExtensionCallback::OnDestroy()
634 {
635     ANS_LOGD("OnDestroy");
636 }
637 
638 
SetSessionId(int32_t sessionId)639 void ModalExtensionCallback::SetSessionId(int32_t sessionId)
640 {
641     this->sessionId_ = sessionId;
642 }
643 
SetBundleName(std::string bundleName)644 void ModalExtensionCallback::SetBundleName(std::string bundleName)
645 {
646     this->bundleName_ = bundleName;
647 }
648 
SetAbilityContext(std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext)649 void ModalExtensionCallback::SetAbilityContext(std::shared_ptr<OHOS::AbilityRuntime::AbilityContext> abilityContext)
650 {
651     this->abilityContext_ = abilityContext;
652 }
653 
ReleaseOrErrorHandle(int32_t code)654 void ModalExtensionCallback::ReleaseOrErrorHandle(int32_t code)
655 {
656     ANS_LOGD("ReleaseOrErrorHandle start");
657     Ace::UIContent* uiContent = this->abilityContext_->GetUIContent();
658     if (uiContent == nullptr) {
659         ANS_LOGE("uiContent is null");
660         return;
661     }
662     uiContent->CloseModalUIExtension(this->sessionId_);
663     ANS_LOGD("ReleaseOrErrorHandle end");
664     return;
665 }
666 
667 }  // namespace NotificationNapi
668 }  // namespace OHOS
669