1 /*
2  * Copyright (c) 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 #include "js_app_overlay.h"
16 
17 #include <string>
18 
19 #include "app_log_wrapper.h"
20 #include "app_control_interface.h"
21 #include "bundle_mgr_interface.h"
22 #include "bundle_mgr_proxy.h"
23 #include "bundle_errors.h"
24 #include "business_error.h"
25 #include "common_func.h"
26 #include "ipc_skeleton.h"
27 #include "napi_arg.h"
28 #include "napi_constants.h"
29 
30 namespace OHOS {
31 namespace AppExecFwk {
32 using namespace OHOS::AAFwk;
33 namespace {
34 const std::string PARAM_TYPE_CHECK_ERROR = "param type check error";
35 const std::string MODULE_NAME = "moduleName";
36 const std::string BUNDLE_NAME = "bundleName";
37 const std::string TARGET_MODULE_NAME = "targetModuleName";
38 const std::string TARGET_BUNDLE_NAME = "targetBundleName";
39 const std::string IS_ENABLED = "isEnabled";
40 const std::string SET_OVERLAY_ENABLED = "SetOverlayEnabled";
41 const std::string SET_OVERLAY_ENABLED_BY_BUNDLE_NAME = "SetOverlayEnabledByBundleName";
42 const std::string GET_OVERLAY_MODULE_INFO = "GetOverlayModuleInfo";
43 const std::string GET_TARGET_OVERLAY_MODULE_INFOS = "GetTargetOverlayModuleInfos";
44 const std::string GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME = "GetOverlayModuleInfoByBundleName";
45 const std::string GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME = "GetTargetOverlayModuleInfosByBundleName";
46 } // namespace
47 
GetOverlayMgrProxy()48 static OHOS::sptr<OHOS::AppExecFwk::IOverlayManager> GetOverlayMgrProxy()
49 {
50     auto bundleMgr = CommonFunc::GetBundleMgr();
51     if (bundleMgr == nullptr) {
52         APP_LOGE("CommonFunc::GetBundleMgr failed");
53         return nullptr;
54     }
55     auto overlayMgrProxy = bundleMgr->GetOverlayManagerProxy();
56     if (overlayMgrProxy == nullptr) {
57         APP_LOGE("GetOverlayManagerProxy failed");
58         return nullptr;
59     }
60     return overlayMgrProxy;
61 }
62 
63 
InnerSetOverlayEnabledExec(napi_env,OverlayCallbackInfo * callback)64 static ErrCode InnerSetOverlayEnabledExec(napi_env, OverlayCallbackInfo *callback)
65 {
66     auto overlayMgrProxy = GetOverlayMgrProxy();
67     if (overlayMgrProxy == nullptr) {
68         APP_LOGE("overlayMgrProxy is null");
69         return ERROR_SYSTEM_ABILITY_NOT_FOUND;
70     }
71     ErrCode ret = ERR_OK;
72     if (callback->option == OverlayOption::OPTION_SET_OVERLAY_ENABLED_BY_BUNDLE) {
73         ret = overlayMgrProxy->SetOverlayEnabled(callback->bundleName, callback->moduleName, callback->isEnabled);
74     } else {
75         ret = overlayMgrProxy->SetOverlayEnabledForSelf(callback->moduleName, callback->isEnabled);
76     }
77     return CommonFunc::ConvertErrCode(ret);
78 }
79 
SetOverlayEnabledExec(napi_env env,void * data)80 void SetOverlayEnabledExec(napi_env env, void *data)
81 {
82     OverlayCallbackInfo *overlayCallbackInfo = reinterpret_cast<OverlayCallbackInfo *>(data);
83     if (overlayCallbackInfo == nullptr) {
84         APP_LOGE("overlayCallbackInfo is null");
85         return;
86     }
87     if (overlayCallbackInfo->err == NO_ERROR) {
88         overlayCallbackInfo->err = InnerSetOverlayEnabledExec(env, overlayCallbackInfo);
89     }
90 }
91 
SetOverlayEnabledComplete(napi_env env,napi_status status,void * data)92 void SetOverlayEnabledComplete(napi_env env, napi_status status, void *data)
93 {
94     OverlayCallbackInfo *overlayCallbackInfo = reinterpret_cast<OverlayCallbackInfo *>(data);
95     if (overlayCallbackInfo == nullptr) {
96         APP_LOGE("overlayCallbackInfo is null");
97         return;
98     }
99     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
100     napi_value result[CALLBACK_PARAM_SIZE] = {0};
101     if (overlayCallbackInfo->err == NO_ERROR) {
102         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
103     } else {
104         APP_LOGE("SetOverlayEnabledComplete err = %{public}d", overlayCallbackInfo->err);
105         result[0] = BusinessError::CreateCommonError(env, overlayCallbackInfo->err,
106             SET_OVERLAY_ENABLED_BY_BUNDLE_NAME, Constants::PERMISSION_CHANGE_OVERLAY_ENABLED_STATE);
107     }
108     CommonFunc::NapiReturnDeferred<OverlayCallbackInfo>(env, overlayCallbackInfo, result, ARGS_SIZE_ONE);
109 }
110 
SetOverlayEnabled(napi_env env,napi_callback_info info)111 napi_value SetOverlayEnabled(napi_env env, napi_callback_info info)
112 {
113     APP_LOGD("NAPI SetOverlayEnabled called");
114     NapiArg args(env, info);
115     OverlayCallbackInfo *overlayCallbackInfo = new (std::nothrow) OverlayCallbackInfo(env);
116     if (overlayCallbackInfo == nullptr) {
117         APP_LOGE("overlayCallbackInfo is null");
118         return nullptr;
119     }
120     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
121     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
122         APP_LOGE("param count invalid");
123         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
124         return nullptr;
125     }
126     for (size_t i = 0; i < args.GetMaxArgc(); i++) {
127         napi_valuetype valueType = napi_undefined;
128         napi_typeof(env, args[i], &valueType);
129         if (i == ARGS_POS_ZERO) {
130             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->moduleName) ||
131                 overlayCallbackInfo->moduleName.empty()) {
132                 APP_LOGE("moduleName %{public}s invalid", overlayCallbackInfo->moduleName.c_str());
133                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
134                 return nullptr;
135             }
136         } else if (i == ARGS_POS_ONE) {
137             if (!CommonFunc::ParseBool(env, args[ARGS_POS_ONE], overlayCallbackInfo->isEnabled)) {
138                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, IS_ENABLED, TYPE_BOOLEAN);
139                 return nullptr;
140             }
141         } else if (i == ARGS_POS_TWO) {
142             if (valueType == napi_function) {
143                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
144             } else {
145                 APP_LOGD("SetOverlayEnabled extra arg ignored");
146             }
147         } else {
148             APP_LOGE("SetOverlayEnabled arg err");
149             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
150             return nullptr;
151         }
152     }
153 
154     overlayCallbackInfo->option = OverlayOption::OPTION_SET_OVERLAY_ENABLED;
155     auto promise = CommonFunc::AsyncCallNativeMethod<OverlayCallbackInfo>(
156         env, overlayCallbackInfo, SET_OVERLAY_ENABLED, SetOverlayEnabledExec, SetOverlayEnabledComplete);
157     callbackPtr.release();
158     APP_LOGD("call SetOverlayEnabled done");
159     return promise;
160 }
161 
SetOverlayEnabledByBundleName(napi_env env,napi_callback_info info)162 napi_value SetOverlayEnabledByBundleName(napi_env env, napi_callback_info info)
163 {
164     APP_LOGD("NAPI SetOverlayEnabledByBundleName called");
165     NapiArg args(env, info);
166     OverlayCallbackInfo *overlayCallbackInfo = new (std::nothrow) OverlayCallbackInfo(env);
167     if (overlayCallbackInfo == nullptr) {
168         APP_LOGE("overlayCallbackInfo is null");
169         return nullptr;
170     }
171     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
172     if (!args.Init(ARGS_SIZE_THREE, ARGS_SIZE_FOUR)) {
173         APP_LOGE("param count invalid");
174         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
175         return nullptr;
176     }
177     for (size_t i = 0; i < args.GetMaxArgc(); i++) {
178         napi_valuetype valueType = napi_undefined;
179         napi_typeof(env, args[i], &valueType);
180         if (i == ARGS_POS_ZERO) {
181             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->bundleName) ||
182                 overlayCallbackInfo->bundleName.empty()) {
183                 APP_LOGE("bundleName %{public}s invalid", overlayCallbackInfo->bundleName.c_str());
184                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
185                 return nullptr;
186             }
187         } else if (i == ARGS_POS_ONE) {
188             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->moduleName) ||
189                 overlayCallbackInfo->moduleName.empty()) {
190                 APP_LOGE("moduleName %{public}s invalid", overlayCallbackInfo->moduleName.c_str());
191                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
192                 return nullptr;
193             }
194         } else if (i == ARGS_POS_TWO) {
195             if (!CommonFunc::ParseBool(env, args[i], overlayCallbackInfo->isEnabled)) {
196                 APP_LOGE("isEnabled is %{public}d invalid", overlayCallbackInfo->isEnabled);
197                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, IS_ENABLED, TYPE_BOOLEAN);
198                 return nullptr;
199             }
200         } else if (i == ARGS_POS_THREE) {
201             if (valueType == napi_function) {
202                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
203             } else {
204                 APP_LOGD("SetOverlayEnabledByBundleName extra arg ignored");
205             }
206         } else {
207             APP_LOGE("SetOverlayEnabledByBundleName arg err");
208             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
209             return nullptr;
210         }
211     }
212 
213     overlayCallbackInfo->option = OverlayOption::OPTION_SET_OVERLAY_ENABLED_BY_BUNDLE;
214     auto promise = CommonFunc::AsyncCallNativeMethod<OverlayCallbackInfo>(
215         env, overlayCallbackInfo, SET_OVERLAY_ENABLED_BY_BUNDLE_NAME, SetOverlayEnabledExec,
216             SetOverlayEnabledComplete);
217     callbackPtr.release();
218     APP_LOGD("call SetOverlayEnabledByBundleName done");
219     return promise;
220 }
221 
InnerGetOverlayModuleInfoExec(napi_env,OverlayCallbackInfo * overlayCbInfo)222 static ErrCode InnerGetOverlayModuleInfoExec(napi_env, OverlayCallbackInfo *overlayCbInfo)
223 {
224     std::string bundleName = CommonFunc::ObtainCallingBundleName();
225     if (bundleName.empty()) {
226         APP_LOGE("obtain calling bundleName failed");
227         return ERROR_BUNDLE_SERVICE_EXCEPTION;
228     }
229 
230     auto overlayMgrProxy = GetOverlayMgrProxy();
231     if (overlayMgrProxy == nullptr) {
232         APP_LOGE("overlayMgrProxy is null");
233         return ERROR_SYSTEM_ABILITY_NOT_FOUND;
234     }
235 
236     ErrCode ret = ERR_OK;
237     if (overlayCbInfo->option == OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO) {
238         ret = overlayMgrProxy->GetOverlayModuleInfo(overlayCbInfo->moduleName,
239             overlayCbInfo->overlayModuleInfo);
240     } else if (overlayCbInfo->option == OverlayOption::OPTION_GET_OVERLAY_TARGET_MODULE_INFO) {
241         ret = overlayMgrProxy->GetTargetOverlayModuleInfo(overlayCbInfo->targetModuleName,
242             overlayCbInfo->infoVec);
243     } else if (overlayCbInfo->option == OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME) {
244         ret = overlayMgrProxy->GetOverlayModuleInfoByBundleName(overlayCbInfo->bundleName, overlayCbInfo->moduleName,
245             overlayCbInfo->infoVec);
246     } else if (overlayCbInfo->option == OverlayOption::OPTION_GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME) {
247         ret = overlayMgrProxy->GetOverlayModuleInfoForTarget(overlayCbInfo->targetBundleName,
248             overlayCbInfo->moduleName, overlayCbInfo->infoVec);
249     } else {
250         APP_LOGE("invalid overlay option");
251         return ERROR_BUNDLE_SERVICE_EXCEPTION;
252     }
253     return CommonFunc::ConvertErrCode(ret);
254 }
255 
GetOverlayModuleInfoExec(napi_env env,void * data)256 void GetOverlayModuleInfoExec(napi_env env, void *data)
257 {
258     OverlayCallbackInfo *overlayCbInfo = reinterpret_cast<OverlayCallbackInfo *>(data);
259     if (overlayCbInfo == nullptr) {
260         APP_LOGE("overlayCbInfo is null");
261         return;
262     }
263     if (overlayCbInfo->err == NO_ERROR) {
264         overlayCbInfo->err = InnerGetOverlayModuleInfoExec(env, overlayCbInfo);
265         return;
266     }
267 }
268 
GetOverlayModuleInfoComplete(napi_env env,napi_status status,void * data)269 void GetOverlayModuleInfoComplete(napi_env env, napi_status status, void *data)
270 {
271     OverlayCallbackInfo *overlayCallbackInfo = reinterpret_cast<OverlayCallbackInfo *>(data);
272     if (overlayCallbackInfo == nullptr) {
273         APP_LOGE("overlayCallbackInfo is null");
274         return;
275     }
276     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
277     napi_value result[CALLBACK_PARAM_SIZE] = {0};
278     if (overlayCallbackInfo->err == NO_ERROR) {
279         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
280         if (overlayCallbackInfo->option == OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO) {
281             NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[ARGS_POS_ONE]));
282             CommonFunc::ConvertOverlayModuleInfo(env, overlayCallbackInfo->overlayModuleInfo, result[ARGS_POS_ONE]);
283         } else {
284             NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[ARGS_POS_ONE]));
285             CommonFunc::ConvertOverlayModuleInfos(env, overlayCallbackInfo->infoVec, result[ARGS_POS_ONE]);
286         }
287     } else {
288         result[ARGS_POS_ZERO] = BusinessError::CreateCommonError(env, overlayCallbackInfo->err,
289             GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
290     }
291     CommonFunc::NapiReturnDeferred<OverlayCallbackInfo>(env, overlayCallbackInfo, result, ARGS_SIZE_TWO);
292 }
293 
GetOverlayModuleInfo(napi_env env,napi_callback_info info)294 napi_value GetOverlayModuleInfo(napi_env env, napi_callback_info info)
295 {
296     APP_LOGD("NAPI GetOverlayModuleInfo called");
297     NapiArg args(env, info);
298     OverlayCallbackInfo *overlayCallbackInfo = new (std::nothrow) OverlayCallbackInfo(env);
299     if (overlayCallbackInfo == nullptr) {
300         APP_LOGE("overlayCallbackInfo is null");
301         return nullptr;
302     }
303     overlayCallbackInfo->option = OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO;
304     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
305     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
306         APP_LOGE("param count invalid");
307         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
308         return nullptr;
309     }
310     for (size_t i = 0; i < args.GetMaxArgc(); i++) {
311         napi_valuetype valueType = napi_undefined;
312         napi_typeof(env, args[i], &valueType);
313         if (i == ARGS_POS_ZERO) {
314             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->moduleName) ||
315                 overlayCallbackInfo->moduleName.empty()) {
316                 APP_LOGE("moduleName %{public}s invalid", overlayCallbackInfo->moduleName.c_str());
317                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
318                 return nullptr;
319             }
320         } else if (i == ARGS_POS_ONE) {
321             if (valueType == napi_function) {
322                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
323             } else {
324                 APP_LOGD("GetOverlayModuleInfo extra arg ignored");
325             }
326         } else {
327             APP_LOGE("GetOverlayModuleInfo arg err");
328             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
329             return nullptr;
330         }
331     }
332     auto promise = CommonFunc::AsyncCallNativeMethod<OverlayCallbackInfo>(
333         env, overlayCallbackInfo, GET_OVERLAY_MODULE_INFO, GetOverlayModuleInfoExec, GetOverlayModuleInfoComplete);
334     callbackPtr.release();
335     APP_LOGD("call GetOverlayModuleInfo done");
336     return promise;
337 }
338 
GetTargetOverlayModuleInfosComplete(napi_env env,napi_status status,void * data)339 void GetTargetOverlayModuleInfosComplete(napi_env env, napi_status status, void *data)
340 {
341     OverlayCallbackInfo *overlayCallbackInfo = reinterpret_cast<OverlayCallbackInfo *>(data);
342     if (overlayCallbackInfo == nullptr) {
343         APP_LOGE("overlayCallbackInfo is null");
344         return;
345     }
346     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
347     napi_value result[CALLBACK_PARAM_SIZE] = {0};
348     if (overlayCallbackInfo->err == NO_ERROR) {
349         NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_POS_ZERO]));
350         NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[ARGS_POS_ONE]));
351         CommonFunc::ConvertOverlayModuleInfos(env, overlayCallbackInfo->infoVec, result[ARGS_POS_ONE]);
352     } else {
353         result[ARGS_POS_ZERO] = BusinessError::CreateCommonError(env, overlayCallbackInfo->err,
354             GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
355     }
356     CommonFunc::NapiReturnDeferred<OverlayCallbackInfo>(env, overlayCallbackInfo, result, ARGS_SIZE_TWO);
357 }
358 
GetTargetOverlayModuleInfos(napi_env env,napi_callback_info info)359 napi_value GetTargetOverlayModuleInfos(napi_env env, napi_callback_info info)
360 {
361     APP_LOGD("NAPI GetTargetOverlayModuleInfos called");
362     NapiArg args(env, info);
363     OverlayCallbackInfo *overlayCallbackInfo = new (std::nothrow) OverlayCallbackInfo(env);
364     if (overlayCallbackInfo == nullptr) {
365         APP_LOGE("overlayCallbackInfo is null");
366         return nullptr;
367     }
368     overlayCallbackInfo->option = OverlayOption::OPTION_GET_OVERLAY_TARGET_MODULE_INFO;
369     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
370     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
371         APP_LOGE("param count invalid");
372         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
373         return nullptr;
374     }
375     for (size_t i = 0; i < args.GetMaxArgc(); i++) {
376         napi_valuetype valueType = napi_undefined;
377         napi_typeof(env, args[i], &valueType);
378         if (i == ARGS_POS_ZERO) {
379             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->targetModuleName) ||
380                 overlayCallbackInfo->targetModuleName.empty()) {
381                 APP_LOGE("targetModuleName %{public}s invalid", overlayCallbackInfo->targetModuleName.c_str());
382                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, TARGET_MODULE_NAME, TYPE_STRING);
383                 return nullptr;
384             }
385         } else if (i == ARGS_POS_ONE) {
386             if (valueType == napi_function) {
387                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
388             } else {
389                 APP_LOGD("GetTargetOverlayModuleInfos extra arg ignored");
390             }
391         } else {
392             APP_LOGE("GetTargetOverlayModuleInfos arg err");
393             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
394             return nullptr;
395         }
396     }
397     auto promise = CommonFunc::AsyncCallNativeMethod<OverlayCallbackInfo>(
398         env, overlayCallbackInfo, GET_TARGET_OVERLAY_MODULE_INFOS, GetOverlayModuleInfoExec,
399         GetTargetOverlayModuleInfosComplete);
400     callbackPtr.release();
401     APP_LOGD("call GetTargetOverlayModuleInfos done");
402     return promise;
403 }
404 
GetOverlayModuleInfoByBundleName(napi_env env,napi_callback_info info)405 napi_value GetOverlayModuleInfoByBundleName(napi_env env, napi_callback_info info)
406 {
407     APP_LOGD("NAPI GetOverlayModuleInfoByBundleName called");
408     NapiArg args(env, info);
409     OverlayCallbackInfo *overlayCallbackInfo = new (std::nothrow) OverlayCallbackInfo(env);
410     if (overlayCallbackInfo == nullptr) {
411         APP_LOGE("overlayCallbackInfo is null");
412         return nullptr;
413     }
414     overlayCallbackInfo->option = OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME;
415     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
416     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
417         APP_LOGE("param count invalid");
418         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
419         return nullptr;
420     }
421     for (size_t i = 0; i < args.GetMaxArgc(); i++) {
422         napi_valuetype valueType = napi_undefined;
423         napi_typeof(env, args[i], &valueType);
424         if (i == ARGS_POS_ZERO) {
425             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->bundleName) ||
426                 overlayCallbackInfo->bundleName.empty()) {
427                 APP_LOGE("bundleName %{public}s invalid", overlayCallbackInfo->bundleName.c_str());
428                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
429                 return nullptr;
430             }
431         } else if (i == ARGS_POS_ONE) {
432             if (valueType == napi_function) {
433                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
434                 break;
435             }
436             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->moduleName)) {
437                 APP_LOGW("Parse moduleName error, default query for all module OverlayModuleInfo");
438             }
439         } else if (i == ARGS_POS_TWO) {
440             if (valueType == napi_function) {
441                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
442                 break;
443             }
444         } else {
445             APP_LOGE("GetOverlayModuleInfoByBundleName arg err");
446             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
447             return nullptr;
448         }
449     }
450 
451     auto promise = CommonFunc::AsyncCallNativeMethod<OverlayCallbackInfo>(
452         env, overlayCallbackInfo, GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME, GetOverlayModuleInfoExec,
453         GetOverlayModuleInfoComplete);
454     callbackPtr.release();
455     APP_LOGD("call GetOverlayModuleInfoByBundleName done");
456     return promise;
457 }
458 
GetTargetOverlayModuleInfosByBundleName(napi_env env,napi_callback_info info)459 napi_value GetTargetOverlayModuleInfosByBundleName(napi_env env, napi_callback_info info)
460 {
461     APP_LOGD("NAPI GetTargetOverlayModuleInfosByBundleName called");
462     NapiArg args(env, info);
463     OverlayCallbackInfo *overlayCallbackInfo = new (std::nothrow) OverlayCallbackInfo(env);
464     if (overlayCallbackInfo == nullptr) {
465         APP_LOGE("overlayCallbackInfo is null");
466         return nullptr;
467     }
468     overlayCallbackInfo->option = OverlayOption::OPTION_GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME;
469     std::unique_ptr<OverlayCallbackInfo> callbackPtr {overlayCallbackInfo};
470     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
471         APP_LOGE("param count invalid");
472         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
473         return nullptr;
474     }
475     for (size_t i = 0; i < args.GetMaxArgc(); i++) {
476         napi_valuetype valueType = napi_undefined;
477         napi_typeof(env, args[i], &valueType);
478         if (i == ARGS_POS_ZERO) {
479             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->targetBundleName) ||
480                 overlayCallbackInfo->targetBundleName.empty()) {
481                 APP_LOGE("targetBundleName %{public}s invalid", overlayCallbackInfo->targetBundleName.c_str());
482                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, TARGET_BUNDLE_NAME, TYPE_STRING);
483                 return nullptr;
484             }
485         } else if (i == ARGS_POS_ONE) {
486             if (valueType == napi_function) {
487                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
488                 break;
489             }
490             if (!CommonFunc::ParseString(env, args[i], overlayCallbackInfo->moduleName)) {
491                 APP_LOGW("Parse moduleName error, default query for all module OverlayModuleInfo");
492             }
493         } else if (i == ARGS_POS_TWO) {
494             if (valueType == napi_function) {
495                 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &overlayCallbackInfo->callback));
496                 break;
497             }
498         } else {
499             APP_LOGE("GetTargetOverlayModuleInfosByBundleName arg err");
500             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
501             return nullptr;
502         }
503     }
504     auto promise = CommonFunc::AsyncCallNativeMethod<OverlayCallbackInfo>(
505         env, overlayCallbackInfo, GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME, GetOverlayModuleInfoExec,
506         GetTargetOverlayModuleInfosComplete);
507     callbackPtr.release();
508     APP_LOGD("call GetTargetOverlayModuleInfosByBundleName done");
509     return promise;
510 }
511 } // AppExecFwk
512 } // OHOS