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 <string>
16 
17 #include "app_log_wrapper.h"
18 #include "bundle_errors.h"
19 #include "bundle_mgr_client.h"
20 #include "bundle_mgr_interface.h"
21 #include "bundle_mgr_proxy.h"
22 #include "business_error.h"
23 #include "bundle_constants.h"
24 #include "common_func.h"
25 #include "hap_module_info.h"
26 #include "ipc_skeleton.h"
27 #include "napi_arg.h"
28 #include "napi_common_want.h"
29 #include "napi_constants.h"
30 #include "bundle_manager_sync.h"
31 
32 namespace OHOS {
33 namespace AppExecFwk {
34 constexpr const char* MODULE_NAME = "moduleName";
35 constexpr const char* ABILITY_NAME = "abilityName";
36 constexpr const char* ABILITY_INFO = "abilityInfo";
37 constexpr const char* IS_ENABLE = "isEnable";
38 constexpr const char* BUNDLE_NAME = "bundleName";
39 constexpr const char* BUNDLE_FLAGS = "bundleFlags";
40 constexpr const char* HAP_FILE_PATH = "hapFilePath";
41 constexpr const char* UID = "uid";
42 constexpr const char* EXTENSIONABILITY_TYPE = "extensionAbilityType";
43 constexpr const char* FLAGS = "flags";
44 constexpr const char* ERR_MSG_BUNDLE_SERVICE_EXCEPTION = "Bundle manager service is excepted.";
45 constexpr const char* EXTENSION_TYPE_NAME = "extensionTypeName";
46 const char* SET_APPLICATION_ENABLED_SYNC = "SetApplicationEnabledSync";
47 const char* SET_ABILITY_ENABLED_SYNC = "SetAbilityEnabledSync";
48 const char* IS_APPLICATION_ENABLED_SYNC = "IsApplicationEnabledSync";
49 const char* IS_ABILITY_ENABLED_SYNC = "IsAbilityEnabledSync";
50 const char* GET_ABILITY_LABEL_SYNC = "GetAbilityLabelSync";
51 const char* GET_LAUNCH_WANT_FOR_BUNDLE_SYNC = "GetLaunchWantForBundleSync";
52 const char* GET_BUNDLE_ARCHIVE_INFO_SYNC = "GetBundleArchiveInfoSync";
53 const char* GET_BUNDLE_NAME_BY_UID_SYNC = "GetBundleNameByUidSync";
54 const char* GET_PROFILE_BY_EXTENSION_ABILITY_SYNC = "GetProfileByExtensionAbilitySync";
55 const char* GET_PROFILE_BY_ABILITY_SYNC = "GetProfileByAbilitySync";
56 const char* QUERY_EXTENSION_INFOS_SYNC = "QueryExtensionInfosSync";
57 const char* GET_PERMISSION_DEF_SYNC = "GetPermissionDefSync";
58 const char* GET_APP_PROVISION_INFO_SYNC = "GetAppProvisionInfoSync";
59 const char* BUNDLE_PERMISSIONS = "ohos.permission.GET_BUNDLE_INFO or ohos.permission.GET_BUNDLE_INFO_PRIVILEGED";
60 const char* PERMISSION_NAME = "permissionName";
61 const char* INVALID_WANT_ERROR =
62     "implicit query condition, at least one query param(action entities uri type or linkFeature) non-empty.";
63 const char* PARAM_TYPE_CHECK_ERROR = "param type check error";
64 const char* PARAM_EXTENSION_ABILITY_TYPE_EMPTY_ERROR =
65     "BusinessError 401: Parameter error.Parameter extensionAbilityType is empty.";
66 const char* LINK_FEATURE = "linkFeature";
ParseWantWithParameter(napi_env env,napi_value args,Want & want)67 bool ParseWantWithParameter(napi_env env, napi_value args, Want &want)
68 {
69     napi_valuetype valueType;
70     NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
71     if (valueType != napi_object) {
72         APP_LOGW("args not object type");
73         return false;
74     }
75     napi_value prop = nullptr;
76     napi_get_named_property(env, args, BUNDLE_NAME, &prop);
77     std::string bundleName = CommonFunc::GetStringFromNAPI(env, prop);
78 
79     prop = nullptr;
80     napi_get_named_property(env, args, MODULE_NAME, &prop);
81     std::string moduleName = CommonFunc::GetStringFromNAPI(env, prop);
82 
83     prop = nullptr;
84     napi_get_named_property(env, args, ABILITY_NAME, &prop);
85     std::string abilityName = CommonFunc::GetStringFromNAPI(env, prop);
86     if (!bundleName.empty() && !abilityName.empty()) {
87         ElementName elementName("", bundleName, abilityName, moduleName);
88         want.SetElement(elementName);
89         return true;
90     }
91     if (!UnwrapWant(env, args, want)) {
92         APP_LOGW("parse want failed");
93         return false;
94     }
95     bool isExplicit = !want.GetBundle().empty() && !want.GetElement().GetAbilityName().empty();
96     if (!isExplicit && want.GetAction().empty() && want.GetEntities().empty() &&
97         want.GetUriString().empty() && want.GetType().empty() && want.GetStringParam(LINK_FEATURE).empty()) {
98         APP_LOGW("implicit params all empty");
99         return false;
100     }
101     return true;
102 }
103 
IsArray(napi_env env,napi_value value)104 bool IsArray(napi_env env, napi_value value)
105 {
106     bool result = false;
107     NAPI_CALL_BASE(env, napi_is_array(env, value, &result), false);
108     return result;
109 }
110 
ParseWantListWithParameter(napi_env env,napi_value args,std::vector<Want> & wants)111 bool ParseWantListWithParameter(napi_env env, napi_value args, std::vector<Want> &wants)
112 {
113     if (!IsArray(env, args)) {
114         return false;
115     }
116 
117     uint32_t length = 0;
118     napi_get_array_length(env, args, &length);
119 
120     for (uint32_t i = 0; i < length; i++) {
121         napi_value array;
122         Want want;
123         napi_get_element(env, args, i, &array);
124         if (!UnwrapWant(env, array, want)) {
125             APP_LOGW("parse want failed");
126             return false;
127         }
128         bool isExplicit = !want.GetBundle().empty() && !want.GetElement().GetAbilityName().empty();
129         if (!isExplicit && want.GetAction().empty() && want.GetEntities().empty() &&
130             want.GetUriString().empty() && want.GetType().empty() && want.GetStringParam(LINK_FEATURE).empty()) {
131             APP_LOGW("implicit params all empty of want %{public}d", i);
132             continue;
133         }
134         wants.push_back(want);
135     }
136 
137     if (wants.empty()) {
138         return false;
139     }
140 
141     return true;
142 }
143 
SetApplicationEnabledSync(napi_env env,napi_callback_info info)144 napi_value SetApplicationEnabledSync(napi_env env, napi_callback_info info)
145 {
146     APP_LOGD("NAPI SetApplicationEnabledSync called");
147     NapiArg args(env, info);
148     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_TWO)) {
149         APP_LOGE("param count invalid");
150         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
151         return nullptr;
152     }
153     std::string bundleName;
154     bool isEnable = false;
155     if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName)) {
156         APP_LOGE("parse bundleName failed");
157         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
158         return nullptr;
159     }
160     if (!CommonFunc::ParseBool(env, args[ARGS_POS_ONE], isEnable)) {
161         APP_LOGE("parse isEnable failed");
162         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, IS_ENABLE, TYPE_BOOLEAN);
163         return nullptr;
164     }
165     auto iBundleMgr = CommonFunc::GetBundleMgr();
166     if (iBundleMgr == nullptr) {
167         APP_LOGE("can not get iBundleMgr");
168         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
169         return nullptr;
170     }
171     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->SetApplicationEnabled(bundleName, isEnable));
172     if (ret != NO_ERROR) {
173         APP_LOGE("SetApplicationEnabledSync failed, bundleName is %{public}s", bundleName.c_str());
174         napi_value businessError = BusinessError::CreateCommonError(
175             env, ret, SET_APPLICATION_ENABLED_SYNC, Constants::PERMISSION_CHANGE_ABILITY_ENABLED_STATE);
176         napi_throw(env, businessError);
177         return nullptr;
178     }
179     napi_value nRet = nullptr;
180     NAPI_CALL(env, napi_get_undefined(env, &nRet));
181     APP_LOGD("call SetApplicationEnabledSync done");
182     return nRet;
183 }
184 
SetAbilityEnabledSync(napi_env env,napi_callback_info info)185 napi_value SetAbilityEnabledSync(napi_env env, napi_callback_info info)
186 {
187     APP_LOGD("NAPI SetAbilityEnabledSync called");
188     NapiArg args(env, info);
189     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_TWO)) {
190         APP_LOGE("param count invalid");
191         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
192         return nullptr;
193     }
194     AbilityInfo abilityInfo;
195     bool isEnable = false;
196     if (!CommonFunc::ParseAbilityInfo(env, args[ARGS_POS_ZERO], abilityInfo)) {
197         APP_LOGE("parse abilityInfo failed");
198         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, ABILITY_INFO, TYPE_OBJECT);
199         return nullptr;
200     }
201     if (!CommonFunc::ParseBool(env, args[ARGS_POS_ONE], isEnable)) {
202         APP_LOGE("parse isEnable failed");
203         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, IS_ENABLE, TYPE_BOOLEAN);
204         return nullptr;
205     }
206     auto iBundleMgr = CommonFunc::GetBundleMgr();
207     if (iBundleMgr == nullptr) {
208         APP_LOGE("can not get iBundleMgr");
209         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
210         return nullptr;
211     }
212     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->SetAbilityEnabled(abilityInfo, isEnable));
213     if (ret != NO_ERROR) {
214         APP_LOGE("SetAbilityEnabledSync failed");
215         napi_value businessError = BusinessError::CreateCommonError(
216             env, ret, SET_ABILITY_ENABLED_SYNC, Constants::PERMISSION_CHANGE_ABILITY_ENABLED_STATE);
217         napi_throw(env, businessError);
218         return nullptr;
219     }
220     napi_value nRet = nullptr;
221     NAPI_CALL(env, napi_get_undefined(env, &nRet));
222     APP_LOGD("call SetAbilityEnabledSync done");
223     return nRet;
224 }
225 
IsApplicationEnabledSync(napi_env env,napi_callback_info info)226 napi_value IsApplicationEnabledSync(napi_env env, napi_callback_info info)
227 {
228     APP_LOGD("NAPI IsApplicationEnabledSync called");
229     NapiArg args(env, info);
230     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_ONE)) {
231         APP_LOGE("param count invalid");
232         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
233         return nullptr;
234     }
235     std::string bundleName;
236     if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName)) {
237         APP_LOGE("parse bundleName failed");
238         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
239         return nullptr;
240     }
241     auto iBundleMgr = CommonFunc::GetBundleMgr();
242     if (iBundleMgr == nullptr) {
243         APP_LOGE("can not get iBundleMgr");
244         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
245         return nullptr;
246     }
247     bool isEnable = false;
248     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->IsApplicationEnabled(bundleName, isEnable));
249     if (ret != NO_ERROR) {
250         APP_LOGE("IsApplicationEnabledSync failed, bundleName is %{public}s", bundleName.c_str());
251         napi_value businessError = BusinessError::CreateCommonError(env, ret, IS_APPLICATION_ENABLED_SYNC);
252         napi_throw(env, businessError);
253         return nullptr;
254     }
255     napi_value nIsEnabled = nullptr;
256     NAPI_CALL(env, napi_get_boolean(env, isEnable, &nIsEnabled));
257     APP_LOGD("call IsApplicationEnabledSync done");
258     return nIsEnabled;
259 }
260 
IsAbilityEnabledSync(napi_env env,napi_callback_info info)261 napi_value IsAbilityEnabledSync(napi_env env, napi_callback_info info)
262 {
263     APP_LOGD("NAPI IsAbilityEnabledSync called");
264     NapiArg args(env, info);
265     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_ONE)) {
266         APP_LOGE("param count invalid");
267         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
268         return nullptr;
269     }
270     AbilityInfo abilityInfo;
271     if (!CommonFunc::ParseAbilityInfo(env, args[ARGS_POS_ZERO], abilityInfo)) {
272         APP_LOGE("parse abilityInfo failed");
273         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, ABILITY_INFO, TYPE_OBJECT);
274         return nullptr;
275     }
276     auto iBundleMgr = CommonFunc::GetBundleMgr();
277     if (iBundleMgr == nullptr) {
278         APP_LOGE("can not get iBundleMgr");
279         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
280         return nullptr;
281     }
282     bool isEnable = false;
283     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->IsAbilityEnabled(abilityInfo, isEnable));
284     if (ret != NO_ERROR) {
285         APP_LOGE("IsAbilityEnabledSync failed");
286         napi_value businessError = BusinessError::CreateCommonError(env, ret, IS_ABILITY_ENABLED_SYNC);
287         napi_throw(env, businessError);
288         return nullptr;
289     }
290     napi_value nIsEnabled = nullptr;
291     NAPI_CALL(env, napi_get_boolean(env, isEnable, &nIsEnabled));
292     APP_LOGD("call IsAbilityEnabledSync done");
293     return nIsEnabled;
294 }
295 
ParamsExtensionTypeSync(napi_env env,napi_valuetype valueType,napi_value args,ExtensionParamInfo & extensionParamInfo)296 bool ParamsExtensionTypeSync(napi_env env, napi_valuetype valueType, napi_value args,
297     ExtensionParamInfo& extensionParamInfo)
298 {
299     if (valueType == napi_number) {
300         extensionParamInfo.isExtensionTypeName = false;
301         return CommonFunc::ParseInt(env, args, extensionParamInfo.extensionAbilityType);
302     } else if (valueType == napi_string) {
303         extensionParamInfo.isExtensionTypeName = true;
304         return CommonFunc::ParseString(env, args, extensionParamInfo.extensionTypeName);
305     }
306     APP_LOGE("Parameter is invalid");
307     return false;
308 }
309 
ParamsProcessQueryExtensionInfosSync(napi_env env,napi_callback_info info,ExtensionParamInfo & extensionParamInfo)310 ErrCode ParamsProcessQueryExtensionInfosSync(napi_env env, napi_callback_info info,
311     ExtensionParamInfo& extensionParamInfo)
312 {
313     NapiArg args(env, info);
314     if (!args.Init(ARGS_SIZE_THREE, ARGS_SIZE_FOUR)) {
315         APP_LOGE("param count invalid");
316         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
317         return ERROR_PARAM_CHECK_ERROR;
318     }
319     for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
320         napi_valuetype valueType = napi_undefined;
321         napi_typeof(env, args[i], &valueType);
322         if (i == ARGS_POS_ZERO) {
323             // parse want with parameter
324             if (!ParseWantWithParameter(env, args[i], extensionParamInfo.want)) {
325                 APP_LOGE("invalid want");
326                 BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, INVALID_WANT_ERROR);
327                 return ERROR_PARAM_CHECK_ERROR;
328             }
329         } else if (i == ARGS_POS_ONE) {
330             if (!ParamsExtensionTypeSync(env, valueType, args[i], extensionParamInfo)) {
331                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR,
332                     (extensionParamInfo.isExtensionTypeName ? EXTENSION_TYPE_NAME : EXTENSIONABILITY_TYPE),
333                     (extensionParamInfo.isExtensionTypeName ? TYPE_STRING : TYPE_NUMBER));
334                 return ERROR_PARAM_CHECK_ERROR;
335             }
336         } else if (i == ARGS_POS_TWO) {
337             if (!CommonFunc::ParseInt(env, args[i], extensionParamInfo.flags)) {
338                 APP_LOGE("invalid flags");
339                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, FLAGS, TYPE_NUMBER);
340                 return ERROR_PARAM_CHECK_ERROR;
341             }
342         } else if (i == ARGS_POS_THREE) {
343             if (!CommonFunc::ParseInt(env, args[i], extensionParamInfo.userId)) {
344                 APP_LOGW("Parse userId failed, set this parameter to the caller userId");
345             }
346         } else {
347             APP_LOGE("parameter is invalid");
348             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
349             return ERROR_PARAM_CHECK_ERROR;
350         }
351     }
352     if (extensionParamInfo.userId == Constants::UNSPECIFIED_USERID) {
353         extensionParamInfo.userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
354     }
355     return ERR_OK;
356 }
357 
ParamsProcessQueryExtensionInfosOnlyWithTypeNameSync(napi_env env,napi_callback_info info,ExtensionParamInfo & extensionParamInfo)358 ErrCode ParamsProcessQueryExtensionInfosOnlyWithTypeNameSync(napi_env env, napi_callback_info info,
359     ExtensionParamInfo& extensionParamInfo)
360 {
361     NapiArg args(env, info);
362     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
363         APP_LOGE("param count invalid");
364         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
365         return ERROR_PARAM_CHECK_ERROR;
366     }
367     for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
368         napi_valuetype valueType = napi_undefined;
369         napi_typeof(env, args[i], &valueType);
370         if (i == ARGS_POS_ZERO) {
371             if (!CommonFunc::ParseString(env, args[i], extensionParamInfo.extensionTypeName)) {
372                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, EXTENSION_TYPE_NAME,
373                     TYPE_STRING);
374                 return ERROR_PARAM_CHECK_ERROR;
375             }
376         } else if (i == ARGS_POS_ONE) {
377             if (!CommonFunc::ParseInt(env, args[i], extensionParamInfo.flags)) {
378                 APP_LOGE("invalid flags");
379                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, FLAGS, TYPE_NUMBER);
380                 return ERROR_PARAM_CHECK_ERROR;
381             }
382         } else if (i == ARGS_POS_TWO) {
383             if (!CommonFunc::ParseInt(env, args[i], extensionParamInfo.userId)) {
384                 APP_LOGW("Parse userId failed, set this parameter to the caller userId");
385             }
386         } else {
387             APP_LOGE("parameter is invalid");
388             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
389             return ERROR_PARAM_CHECK_ERROR;
390         }
391     }
392     if (extensionParamInfo.extensionTypeName.empty()) {
393         APP_LOGE("The input extensionAbilityType is empty");
394         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_EXTENSION_ABILITY_TYPE_EMPTY_ERROR);
395         return ERROR_PARAM_CHECK_ERROR;
396     }
397     if (extensionParamInfo.userId == Constants::UNSPECIFIED_USERID) {
398         extensionParamInfo.userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
399     }
400     return ERR_OK;
401 }
402 
QueryExtensionInfosSync(napi_env env,napi_callback_info info,ExtensionParamInfo extensionParamInfo,std::vector<ExtensionAbilityInfo> & extensionInfos)403 ErrCode QueryExtensionInfosSync(napi_env env, napi_callback_info info,
404     ExtensionParamInfo extensionParamInfo, std::vector<ExtensionAbilityInfo>& extensionInfos)
405 {
406     if (ParamsProcessQueryExtensionInfosSync(env, info, extensionParamInfo) != ERR_OK) {
407         APP_LOGE("paramsProcess is invalid");
408         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
409         return ERROR_PARAM_CHECK_ERROR;
410     }
411     ErrCode ret;
412     auto iBundleMgr = CommonFunc::GetBundleMgr();
413     if (iBundleMgr == nullptr) {
414         APP_LOGE("can not get iBundleMgr");
415         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
416         return ERROR_BUNDLE_SERVICE_EXCEPTION;
417     }
418     if (!extensionParamInfo.isExtensionTypeName) {
419         if (extensionParamInfo.extensionAbilityType == static_cast<int32_t>(ExtensionAbilityType::UNSPECIFIED)) {
420             APP_LOGD("Query extensionAbilityInfo sync without type");
421             ret = CommonFunc::ConvertErrCode(iBundleMgr->QueryExtensionAbilityInfosV9(extensionParamInfo.want,
422                 extensionParamInfo.flags, extensionParamInfo.userId, extensionInfos));
423         } else {
424             ExtensionAbilityType type = static_cast<ExtensionAbilityType>(extensionParamInfo.extensionAbilityType);
425             APP_LOGD("Query extensionAbilityInfo sync with type %{public}d", extensionParamInfo.extensionAbilityType);
426             ret = CommonFunc::ConvertErrCode(iBundleMgr->QueryExtensionAbilityInfosV9(extensionParamInfo.want,
427                 type, extensionParamInfo.flags, extensionParamInfo.userId, extensionInfos));
428         }
429     } else {
430         APP_LOGD("Query extensionAbilityInfo sync with extensionTypeName %{public}s",
431             extensionParamInfo.extensionTypeName.c_str());
432         ret = CommonFunc::ConvertErrCode(iBundleMgr->QueryExtensionAbilityInfosWithTypeName(extensionParamInfo.want,
433             extensionParamInfo.extensionTypeName, extensionParamInfo.flags, extensionParamInfo.userId,
434             extensionInfos));
435     }
436     return ret;
437 }
438 
QueryExtensionInfosSyncOnlyWithTypeName(napi_env env,napi_callback_info info,ExtensionParamInfo extensionParamInfo,std::vector<ExtensionAbilityInfo> & extensionInfos)439 ErrCode QueryExtensionInfosSyncOnlyWithTypeName(napi_env env, napi_callback_info info,
440     ExtensionParamInfo extensionParamInfo, std::vector<ExtensionAbilityInfo>& extensionInfos)
441 {
442     if (ParamsProcessQueryExtensionInfosOnlyWithTypeNameSync(env, info, extensionParamInfo) != ERR_OK) {
443         APP_LOGE("paramsProcess is invalid");
444         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
445         return ERROR_PARAM_CHECK_ERROR;
446     }
447     ErrCode ret;
448     auto iBundleMgr = CommonFunc::GetBundleMgr();
449     if (iBundleMgr == nullptr) {
450         APP_LOGE("can not get iBundleMgr");
451         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
452         return ERROR_BUNDLE_SERVICE_EXCEPTION;
453     }
454     uint32_t flags = static_cast<uint32_t>(extensionParamInfo.flags);
455     if (extensionParamInfo.flags < 0) {
456         flags = 0;
457     }
458     ret = CommonFunc::ConvertErrCode(iBundleMgr->QueryExtensionAbilityInfosOnlyWithTypeName(
459         extensionParamInfo.extensionTypeName, flags, extensionParamInfo.userId,
460         extensionInfos));
461     return ret;
462 }
463 
QueryExtensionInfosSync(napi_env env,napi_callback_info info)464 napi_value QueryExtensionInfosSync(napi_env env, napi_callback_info info)
465 {
466     APP_LOGD("NAPI QueryExtensionInfosSync call");
467     ExtensionParamInfo extensionParamInfo;
468     NapiArg args(env, info);
469     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_FOUR)) {
470         APP_LOGE("param count invalid");
471         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
472         return nullptr;
473     }
474     napi_valuetype firstValueType = napi_undefined;
475     napi_typeof(env, args[0], &firstValueType);
476     std::vector<ExtensionAbilityInfo> extensionInfos;
477     ErrCode ret;
478     if (firstValueType == napi_object) {
479         ret = QueryExtensionInfosSync(env, info, extensionParamInfo, extensionInfos);
480     } else {
481         ret = QueryExtensionInfosSyncOnlyWithTypeName(env, info, extensionParamInfo, extensionInfos);
482     }
483     if (ret != NO_ERROR) {
484         APP_LOGE("QueryExtensionAbilityInfosV9 failed");
485         napi_value businessError = BusinessError::CreateCommonError(
486             env, ret, QUERY_EXTENSION_INFOS_SYNC, BUNDLE_PERMISSIONS);
487         napi_throw(env, businessError);
488         return nullptr;
489     }
490     napi_value nExtensionInfos = nullptr;
491     NAPI_CALL(env, napi_create_array(env, &nExtensionInfos));
492     CommonFunc::ConvertExtensionInfos(env, extensionInfos, nExtensionInfos);
493     APP_LOGD("call QueryExtensionInfosSync done");
494     return nExtensionInfos;
495 }
496 
GetPermissionDefSync(napi_env env,napi_callback_info info)497 napi_value GetPermissionDefSync(napi_env env, napi_callback_info info)
498 {
499     APP_LOGD("GetPermissionDefSync called");
500     NapiArg args(env, info);
501     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_ONE)) {
502         APP_LOGE("param count invalid");
503         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
504         return nullptr;
505     }
506     std::string permissionName;
507     if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], permissionName)) {
508         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, PERMISSION_NAME, TYPE_STRING);
509         return nullptr;
510     }
511     auto iBundleMgr = CommonFunc::GetBundleMgr();
512     if (iBundleMgr == nullptr) {
513         APP_LOGE("can not get iBundleMgr");
514         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
515         return nullptr;
516     }
517     OHOS::AppExecFwk::PermissionDef permissionDef;
518     ErrCode ret = CommonFunc::ConvertErrCode(
519         iBundleMgr->GetPermissionDef(permissionName, permissionDef));
520     if (ret != NO_ERROR) {
521         APP_LOGE("GetPermissionDef failed, permissionName is %{public}s", permissionName.c_str());
522         napi_value businessError = BusinessError::CreateCommonError(
523             env, ret, GET_PERMISSION_DEF_SYNC, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
524         napi_throw(env, businessError);
525         return nullptr;
526     }
527     napi_value nPermissionDef = nullptr;
528     NAPI_CALL(env, napi_create_object(env, &nPermissionDef));
529     CommonFunc::ConvertPermissionDef(env, nPermissionDef, permissionDef);
530     APP_LOGD("call GetPermissionDefSync done");
531     return nPermissionDef;
532 }
533 
ParamsProcessGetAbilityLabelSync(napi_env env,napi_callback_info info,std::string & bundleName,std::string & moduleName,std::string & abilityName)534 ErrCode ParamsProcessGetAbilityLabelSync(napi_env env, napi_callback_info info,
535     std::string& bundleName, std::string& moduleName, std::string& abilityName)
536 {
537     NapiArg args(env, info);
538     if (!args.Init(ARGS_SIZE_THREE, ARGS_SIZE_THREE)) {
539         APP_LOGE("param count invalid");
540         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
541         return ERROR_PARAM_CHECK_ERROR;
542     }
543     if (args.GetMaxArgc() >= ARGS_SIZE_THREE) {
544         if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName)) {
545             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
546             return ERROR_PARAM_CHECK_ERROR;
547         }
548         if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], moduleName)) {
549             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
550             return ERROR_PARAM_CHECK_ERROR;
551         }
552         if (!CommonFunc::ParseString(env, args[ARGS_POS_TWO], abilityName)) {
553             BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, ABILITY_NAME, TYPE_STRING);
554             return ERROR_PARAM_CHECK_ERROR;
555         }
556     } else {
557         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
558         return ERROR_PARAM_CHECK_ERROR;
559     }
560     return ERR_OK;
561 }
562 
GetAbilityLabelSync(napi_env env,napi_callback_info info)563 napi_value GetAbilityLabelSync(napi_env env, napi_callback_info info)
564 {
565     APP_LOGD("begin to GetAbilityLabelSync");
566 #ifdef GLOBAL_RESMGR_ENABLE
567     std::string bundleName;
568     std::string moduleName;
569     std::string abilityName;
570     if (ParamsProcessGetAbilityLabelSync(env, info, bundleName, moduleName, abilityName) != ERR_OK) {
571         APP_LOGE("paramsProcess is invalid");
572         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
573         return nullptr;
574     }
575     auto iBundleMgr = CommonFunc::GetBundleMgr();
576     if (iBundleMgr == nullptr) {
577         APP_LOGE("can not get iBundleMgr");
578         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
579         return nullptr;
580     }
581     std::string abilityLabel;
582     ErrCode ret = CommonFunc::ConvertErrCode(
583         iBundleMgr->GetAbilityLabel(bundleName, moduleName, abilityName, abilityLabel));
584     if (ret != NO_ERROR) {
585         APP_LOGE("GetAbilityLabel failed, bundleName is %{public}s", bundleName.c_str());
586         napi_value businessError = BusinessError::CreateCommonError(
587             env, ret, GET_ABILITY_LABEL_SYNC, BUNDLE_PERMISSIONS);
588         napi_throw(env, businessError);
589         return nullptr;
590     }
591     napi_value nAbilityLabel = nullptr;
592     napi_create_string_utf8(env, abilityLabel.c_str(), NAPI_AUTO_LENGTH, &nAbilityLabel);
593     APP_LOGD("call GetAbilityLabelSync done");
594     return nAbilityLabel;
595 #else
596     APP_LOGE("SystemCapability.BundleManager.BundleFramework.Resource not supported");
597     napi_value error = BusinessError::CreateCommonError(env, ERROR_SYSTEM_ABILITY_NOT_FOUND, "getAbilityLabel");
598     napi_throw(env, error);
599     return nullptr;
600 #endif
601 }
602 
ParamsProcessGetLaunchWantForBundleSync(napi_env env,napi_callback_info info,std::string & bundleName,int32_t & userId)603 ErrCode ParamsProcessGetLaunchWantForBundleSync(napi_env env, napi_callback_info info,
604     std::string& bundleName, int32_t& userId)
605 {
606     NapiArg args(env, info);
607     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
608         APP_LOGE("param count invalid");
609         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
610         return ERROR_PARAM_CHECK_ERROR;
611     }
612     for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
613         napi_valuetype valueType = napi_undefined;
614         napi_typeof(env, args[i], &valueType);
615         if (i == ARGS_POS_ZERO) {
616             if (!CommonFunc::ParseString(env, args[i], bundleName)) {
617                 APP_LOGE("bundleName %{public}s invalid", bundleName.c_str());
618                 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
619                 return ERROR_PARAM_CHECK_ERROR;
620             }
621         } else if (i == ARGS_POS_ONE) {
622             if (!CommonFunc::ParseInt(env, args[i], userId)) {
623                 APP_LOGW("userId parseInt failed");
624             }
625         } else {
626             APP_LOGE("parameter is invalid");
627             BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
628             return ERROR_PARAM_CHECK_ERROR;
629         }
630     }
631     if (bundleName.size() == 0) {
632         return ERROR_PARAM_CHECK_ERROR;
633     }
634     if (userId == Constants::UNSPECIFIED_USERID) {
635         userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
636     }
637     return ERR_OK;
638 }
639 
GetLaunchWantForBundleSync(napi_env env,napi_callback_info info)640 napi_value GetLaunchWantForBundleSync(napi_env env, napi_callback_info info)
641 {
642     APP_LOGD("NAPI GetLaunchWantForBundleSync call");
643     std::string bundleName;
644     int32_t userId = Constants::UNSPECIFIED_USERID;
645     if (ParamsProcessGetLaunchWantForBundleSync(env, info, bundleName, userId) != ERR_OK) {
646         APP_LOGE("paramsProcess is invalid");
647         BusinessError::ThrowError(env, ERROR_PARAM_CHECK_ERROR, PARAM_TYPE_CHECK_ERROR);
648         return nullptr;
649     }
650     auto iBundleMgr = CommonFunc::GetBundleMgr();
651     if (iBundleMgr == nullptr) {
652         APP_LOGE("can not get iBundleMgr");
653         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
654         return nullptr;
655     }
656     OHOS::AAFwk::Want want;
657     ErrCode ret = CommonFunc::ConvertErrCode(
658         iBundleMgr->GetLaunchWantForBundle(bundleName, want, userId));
659     if (ret != NO_ERROR) {
660         APP_LOGE("GetLaunchWantForBundle failed, bundleName is %{public}s, userId is %{public}d",
661             bundleName.c_str(), userId);
662         napi_value businessError = BusinessError::CreateCommonError(
663             env, ret, GET_LAUNCH_WANT_FOR_BUNDLE_SYNC, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
664         napi_throw(env, businessError);
665         return nullptr;
666     }
667     napi_value nWant = nullptr;
668     NAPI_CALL(env, napi_create_object(env, &nWant));
669     CommonFunc::ConvertWantInfo(env, nWant, want);
670     APP_LOGD("call GetLaunchWantForBundleSync done");
671     return nWant;
672 }
673 
GetBundleArchiveInfoSync(napi_env env,napi_callback_info info)674 napi_value GetBundleArchiveInfoSync(napi_env env, napi_callback_info info)
675 {
676     APP_LOGD("NAPI getBundleArchiveInfoSync called");
677     NapiArg args(env, info);
678     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_TWO)) {
679         APP_LOGE("param count invalid");
680         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
681         return nullptr;
682     }
683     std::string hapFilePath;
684     if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], hapFilePath)) {
685         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, HAP_FILE_PATH, TYPE_STRING);
686         return nullptr;
687     }
688     int32_t bundleFlags;
689     if (!CommonFunc::ParseInt(env, args[ARGS_POS_ONE], bundleFlags)) {
690         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_FLAGS, TYPE_NUMBER);
691         return nullptr;
692     }
693     auto iBundleMgr = CommonFunc::GetBundleMgr();
694     if (iBundleMgr == nullptr) {
695         napi_value error = BusinessError::CreateCommonError(env, ERROR_BUNDLE_SERVICE_EXCEPTION,
696             GET_BUNDLE_ARCHIVE_INFO_SYNC, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
697         napi_throw(env, error);
698         return nullptr;
699     }
700     BundleInfo bundleInfo;
701     ErrCode ret = CommonFunc::ConvertErrCode(
702         iBundleMgr->GetBundleArchiveInfoV9(hapFilePath, bundleFlags, bundleInfo));
703     if (ret != ERR_OK) {
704         APP_LOGE("getBundleArchiveInfoSync failed");
705         napi_value businessError = BusinessError::CreateCommonError(
706             env, ret, GET_BUNDLE_ARCHIVE_INFO_SYNC, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
707         napi_throw(env, businessError);
708         return nullptr;
709     }
710     napi_value nBundleInfo = nullptr;
711     NAPI_CALL(env, napi_create_object(env, &nBundleInfo));
712     CommonFunc::ConvertBundleInfo(env, bundleInfo, nBundleInfo, bundleFlags);
713     APP_LOGD("call getBundleArchiveInfoSync done");
714     return nBundleInfo;
715 }
716 
GetBundleNameByUidSync(napi_env env,napi_callback_info info)717 napi_value GetBundleNameByUidSync(napi_env env, napi_callback_info info)
718 {
719     APP_LOGD("NAPI GetBundleNameByUidSync called");
720     NapiArg args(env, info);
721     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_ONE)) {
722         APP_LOGE("param count invalid");
723         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
724         return nullptr;
725     }
726     int32_t uid = -1;
727     if (!CommonFunc::ParseInt(env, args[ARGS_POS_ZERO], uid)) {
728         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, UID, TYPE_NUMBER);
729         return nullptr;
730     }
731     auto iBundleMgr = CommonFunc::GetBundleMgr();
732     if (iBundleMgr == nullptr) {
733         napi_value error = BusinessError::CreateCommonError(env, ERROR_BUNDLE_SERVICE_EXCEPTION,
734             GET_BUNDLE_NAME_BY_UID_SYNC, BUNDLE_PERMISSIONS);
735         napi_throw(env, error);
736         return nullptr;
737     }
738     std::string bundleName;
739     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->GetNameForUid(uid, bundleName));
740     if (ret != ERR_OK) {
741         if (uid > Constants::BASE_APP_UID) {
742             APP_LOGE("failed uid: %{public}d bundleName: %{public}s", uid, bundleName.c_str());
743         }
744         napi_value businessError = BusinessError::CreateCommonError(
745             env, ret, GET_BUNDLE_NAME_BY_UID_SYNC, BUNDLE_PERMISSIONS);
746         napi_throw(env, businessError);
747         return nullptr;
748     }
749     napi_value nBundleName = nullptr;
750     napi_create_string_utf8(env, bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName);
751     APP_LOGD("call GetBundleNameByUidSync done");
752     return nBundleName;
753 }
754 
ParamsProcessGetProfileByAbilitySync(napi_env env,napi_callback_info info,std::string & moduleName,std::string & abilityName,std::string & metadataName)755 ErrCode ParamsProcessGetProfileByAbilitySync(napi_env env, napi_callback_info info,
756     std::string& moduleName, std::string& abilityName, std::string& metadataName)
757 {
758     NapiArg args(env, info);
759     if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
760         APP_LOGE("param count invalid");
761         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
762         return ERROR_PARAM_CHECK_ERROR;
763     }
764     if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], moduleName)) {
765         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
766         return ERROR_PARAM_CHECK_ERROR;
767     }
768     if (moduleName.empty()) {
769         APP_LOGE("param failed due to empty moduleName");
770         napi_value businessError = BusinessError::CreateCommonError(env, ERROR_MODULE_NOT_EXIST);
771         napi_throw(env, businessError);
772         return ERROR_MODULE_NOT_EXIST;
773     }
774     if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], abilityName)) {
775         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, ABILITY_NAME, TYPE_STRING);
776         return ERROR_PARAM_CHECK_ERROR;
777     }
778     if (abilityName.empty()) {
779         APP_LOGE("param failed due to empty abilityName");
780         napi_value businessError = BusinessError::CreateCommonError(env, ERROR_ABILITY_NOT_EXIST);
781         napi_throw(env, businessError);
782         return ERROR_ABILITY_NOT_EXIST;
783     }
784     if (args.GetMaxArgc() == ARGS_SIZE_THREE) {
785         if (!CommonFunc::ParseString(env, args[ARGS_POS_TWO], metadataName)) {
786             APP_LOGW("Parse metadataName param failed");
787         }
788     }
789     return ERR_OK;
790 }
791 
CheckAbilityFromBundleInfo(const BundleInfo & bundleInfo,const std::string & abilityName,const std::string & moduleName,AbilityInfo & targetAbilityInfo)792 ErrCode CheckAbilityFromBundleInfo(const BundleInfo& bundleInfo, const std::string& abilityName,
793     const std::string& moduleName, AbilityInfo& targetAbilityInfo)
794 {
795     for (const auto& hapModuleInfo : bundleInfo.hapModuleInfos) {
796         for (const auto& abilityInfo : hapModuleInfo.abilityInfos) {
797             if (abilityInfo.name == abilityName && abilityInfo.moduleName == moduleName) {
798                 if (!abilityInfo.enabled) {
799                     APP_LOGI("ability disabled");
800                     return ERROR_ABILITY_IS_DISABLED;
801                 }
802                 targetAbilityInfo = abilityInfo;
803                 return ERR_OK;
804             }
805         }
806     }
807     return ERROR_ABILITY_NOT_EXIST;
808 }
809 
GetProfileByAbilitySync(napi_env env,napi_callback_info info)810 napi_value GetProfileByAbilitySync(napi_env env, napi_callback_info info)
811 {
812     APP_LOGD("NAPI GetProfileByAbilitySync called");
813     std::string moduleName;
814     std::string abilityName;
815     std::string metadataName;
816     if (ParamsProcessGetProfileByAbilitySync(env, info, moduleName, abilityName, metadataName) != ERR_OK) {
817         return nullptr;
818     }
819     auto iBundleMgr = CommonFunc::GetBundleMgr();
820     if (iBundleMgr == nullptr) {
821         napi_value error = BusinessError::CreateCommonError(env, ERROR_BUNDLE_SERVICE_EXCEPTION,
822             GET_PROFILE_BY_ABILITY_SYNC);
823         napi_throw(env, error);
824         return nullptr;
825     }
826     auto baseFlag = static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE) +
827            static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA) +
828            static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_DISABLE);
829     auto getAbilityFlag = baseFlag + static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY);
830     BundleInfo bundleInfo;
831     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->GetBundleInfoForSelf(getAbilityFlag, bundleInfo));
832     if (ret != ERR_OK) {
833         APP_LOGE("GetProfileByAbilitySync failed");
834         napi_value businessError = BusinessError::CreateCommonError(env, ret, GET_PROFILE_BY_ABILITY_SYNC);
835         napi_throw(env, businessError);
836         return nullptr;
837     }
838     AbilityInfo targetAbilityInfo;
839     ret = CheckAbilityFromBundleInfo(bundleInfo, abilityName, moduleName, targetAbilityInfo);
840     if (ret != ERR_OK) {
841         APP_LOGE("GetProfileByAbilitySync failed by CheckAbilityFromBundleInfo");
842         napi_value businessError = BusinessError::CreateCommonError(env, ret, GET_PROFILE_BY_ABILITY_SYNC);
843         napi_throw(env, businessError);
844         return nullptr;
845     }
846     BundleMgrClient client;
847     std::vector<std::string> profileVec;
848     if (!client.GetProfileFromAbility(targetAbilityInfo, metadataName, profileVec)) {
849         APP_LOGE("GetProfileByAbilitySync failed by GetProfileFromAbility");
850         napi_value businessError = BusinessError::CreateCommonError(
851             env, ERROR_PROFILE_NOT_EXIST, GET_PROFILE_BY_ABILITY_SYNC);
852         napi_throw(env, businessError);
853         return nullptr;
854     }
855     napi_value nProfileInfos = nullptr;
856     NAPI_CALL(env, napi_create_array(env, &nProfileInfos));
857     CommonFunc::ConvertStringArrays(env, profileVec, nProfileInfos);
858     return nProfileInfos;
859 }
860 
CheckExtensionFromBundleInfo(const BundleInfo & bundleInfo,const std::string & abilityName,const std::string & moduleName,ExtensionAbilityInfo & targetExtensionInfo)861 ErrCode CheckExtensionFromBundleInfo(const BundleInfo& bundleInfo, const std::string& abilityName,
862     const std::string& moduleName, ExtensionAbilityInfo& targetExtensionInfo)
863 {
864     for (const auto& hapModuleInfo : bundleInfo.hapModuleInfos) {
865         for (const auto& extensionInfo : hapModuleInfo.extensionInfos) {
866             if (extensionInfo.name == abilityName && extensionInfo.moduleName == moduleName) {
867                 if (!extensionInfo.enabled) {
868                     APP_LOGI("extension disabled");
869                     return ERROR_ABILITY_IS_DISABLED;
870                 }
871                 targetExtensionInfo = extensionInfo;
872                 return ERR_OK;
873             }
874         }
875     }
876     return ERROR_ABILITY_NOT_EXIST;
877 }
878 
GetProfileByExAbilitySync(napi_env env,napi_callback_info info)879 napi_value GetProfileByExAbilitySync(napi_env env, napi_callback_info info)
880 {
881     APP_LOGD("NAPI GetProfileByExAbilitySync called");
882     std::string moduleName;
883     std::string extensionAbilityName;
884     std::string metadataName;
885     if (ParamsProcessGetProfileByAbilitySync(env, info, moduleName, extensionAbilityName, metadataName) != ERR_OK) {
886         return nullptr;
887     }
888     auto iBundleMgr = CommonFunc::GetBundleMgr();
889     if (iBundleMgr == nullptr) {
890         napi_value error = BusinessError::CreateCommonError(env, ERROR_BUNDLE_SERVICE_EXCEPTION,
891             GET_PROFILE_BY_EXTENSION_ABILITY_SYNC);
892         napi_throw(env, error);
893         return nullptr;
894     }
895     auto baseFlag = static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE) +
896            static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA) +
897            static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_DISABLE);
898     auto getExtensionFlag = baseFlag +
899         static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY);
900     BundleInfo bundleInfo;
901     ErrCode ret = CommonFunc::ConvertErrCode(iBundleMgr->GetBundleInfoForSelf(getExtensionFlag, bundleInfo));
902     if (ret != ERR_OK) {
903         APP_LOGE("GetProfileByExAbilitySync failed");
904         napi_value businessError = BusinessError::CreateCommonError(env, ret, GET_PROFILE_BY_EXTENSION_ABILITY_SYNC);
905         napi_throw(env, businessError);
906         return nullptr;
907     }
908     ExtensionAbilityInfo targetExtensionInfo;
909     ret = CheckExtensionFromBundleInfo(bundleInfo, extensionAbilityName, moduleName, targetExtensionInfo);
910     if (ret != ERR_OK) {
911         APP_LOGE("GetProfileByExAbilitySync failed by CheckExtensionFromBundleInfo");
912         napi_value businessError = BusinessError::CreateCommonError(env, ret, GET_PROFILE_BY_EXTENSION_ABILITY_SYNC);
913         napi_throw(env, businessError);
914         return nullptr;
915     }
916     BundleMgrClient client;
917     std::vector<std::string> profileVec;
918     if (!client.GetProfileFromExtension(targetExtensionInfo, metadataName, profileVec)) {
919         APP_LOGE("GetProfileByExAbilitySync failed by GetProfileFromExtension");
920         napi_value businessError = BusinessError::CreateCommonError(
921             env, ERROR_PROFILE_NOT_EXIST, GET_PROFILE_BY_EXTENSION_ABILITY_SYNC);
922         napi_throw(env, businessError);
923         return nullptr;
924     }
925     napi_value nProfileInfos = nullptr;
926     NAPI_CALL(env, napi_create_array(env, &nProfileInfos));
927     CommonFunc::ConvertStringArrays(env, profileVec, nProfileInfos);
928     return nProfileInfos;
929 }
930 
GetAppProvisionInfoSync(napi_env env,napi_callback_info info)931 napi_value GetAppProvisionInfoSync(napi_env env, napi_callback_info info)
932 {
933     APP_LOGD("NAPI GetAppProvisionInfoSync called");
934     NapiArg args(env, info);
935     if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
936         APP_LOGE("param count invalid");
937         BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
938         return nullptr;
939     }
940     std::string bundleName;
941     if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName)) {
942         BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
943         return nullptr;
944     }
945     CHECK_STRING_EMPTY(env, bundleName, std::string{ BUNDLE_NAME });
946     int32_t userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
947     if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
948         if (!CommonFunc::ParseInt(env, args[ARGS_POS_ONE], userId)) {
949             APP_LOGW("Parse userId failed, set this parameter to the caller userId");
950         }
951     }
952     auto iBundleMgr = CommonFunc::GetBundleMgr();
953     if (iBundleMgr == nullptr) {
954         BusinessError::ThrowError(env, ERROR_BUNDLE_SERVICE_EXCEPTION, ERR_MSG_BUNDLE_SERVICE_EXCEPTION);
955         return nullptr;
956     }
957     AppProvisionInfo appProvisionInfo;
958     ErrCode ret = CommonFunc::ConvertErrCode(
959         iBundleMgr->GetAppProvisionInfo(bundleName, userId, appProvisionInfo));
960     if (ret != ERR_OK) {
961         APP_LOGE_NOFUNC("GetAppProvisionInfoSync fail -n %{public}s -u %{public}d ret:%{public}d",
962             bundleName.c_str(), userId, ret);
963         napi_value businessError = BusinessError::CreateCommonError(
964             env, ret, GET_APP_PROVISION_INFO_SYNC, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
965         napi_throw(env, businessError);
966         return nullptr;
967     }
968     napi_value nAppProvisionInfo = nullptr;
969     NAPI_CALL(env, napi_create_object(env, &nAppProvisionInfo));
970     CommonFunc::ConvertAppProvisionInfo(env, appProvisionInfo, nAppProvisionInfo);
971     APP_LOGD("call GetAppProvisionInfoSync done");
972     return nAppProvisionInfo;
973 }
974 }  // namespace AppExecFwk
975 }  // namespace OHOS
976