1 /*
2 * Copyright (c) 2023-2025 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 "bundle_resource.h"
17
18 #include "app_log_wrapper.h"
19 #include "bundle_errors.h"
20 #include "bundle_mgr_interface.h"
21 #include "bundle_mgr_proxy.h"
22 #include "bundle_resource_drawable_utils.h"
23 #include "business_error.h"
24 #include "common_func.h"
25 #include "iservice_registry.h"
26 #include "napi_arg.h"
27 #include "napi_constants.h"
28 #include "napi/native_api.h"
29 #include "napi/native_common.h"
30 #include "napi/native_node_api.h"
31 #include "resource_helper.h"
32 #include "system_ability_definition.h"
33
34 namespace OHOS {
35 namespace AppExecFwk {
36 namespace {
37 constexpr const char* LABEL = "label";
38 constexpr const char* ICON = "icon";
39 constexpr const char* DRAWABLE_DESCRIPTOR = "drawableDescriptor";
40 constexpr const char* GET_RESOURCE_INFO_ALL = "GET_RESOURCE_INFO_ALL";
41 constexpr const char* GET_RESOURCE_INFO_WITH_LABEL = "GET_RESOURCE_INFO_WITH_LABEL";
42 constexpr const char* GET_RESOURCE_INFO_WITH_ICON = "GET_RESOURCE_INFO_WITH_ICON";
43 constexpr const char* GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL = "GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL";
44 constexpr const char* GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR = "GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR";
45 constexpr const char* GET_RESOURCE_INFO_ONLY_WITH_MAIN_ABILITY = "GET_RESOURCE_INFO_ONLY_WITH_MAIN_ABILITY";
46
ConvertBundleResourceInfo(napi_env env,const BundleResourceInfo & bundleResourceInfo,napi_value objBundleResourceInfo)47 static void ConvertBundleResourceInfo(
48 napi_env env,
49 const BundleResourceInfo &bundleResourceInfo,
50 napi_value objBundleResourceInfo)
51 {
52 APP_LOGD("start");
53 napi_value nBundleName;
54 NAPI_CALL_RETURN_VOID(
55 env, napi_create_string_utf8(env, bundleResourceInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
56 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleResourceInfo, BUNDLE_NAME, nBundleName));
57
58 napi_value nLabel;
59 NAPI_CALL_RETURN_VOID(
60 env, napi_create_string_utf8(env, bundleResourceInfo.label.c_str(),
61 NAPI_AUTO_LENGTH, &nLabel));
62 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleResourceInfo, LABEL, nLabel));
63
64 napi_value nIcon;
65 NAPI_CALL_RETURN_VOID(
66 env, napi_create_string_utf8(env, bundleResourceInfo.icon.c_str(),
67 NAPI_AUTO_LENGTH, &nIcon));
68 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleResourceInfo, ICON, nIcon));
69
70 napi_value nDrawableDescriptor = BundleResourceDrawableUtils::ConvertToDrawableDescriptor(
71 env, bundleResourceInfo.foreground, bundleResourceInfo.background);
72 if (nDrawableDescriptor == nullptr) {
73 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nDrawableDescriptor));
74 }
75 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleResourceInfo,
76 DRAWABLE_DESCRIPTOR, nDrawableDescriptor));
77
78 napi_value nAppIndex;
79 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleResourceInfo.appIndex, &nAppIndex));
80 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleResourceInfo, APP_INDEX, nAppIndex));
81 APP_LOGD("end");
82 }
83
ConvertBundleResourceInfos(napi_env env,const std::vector<BundleResourceInfo> & bundleResourceInfos,napi_value objBundleResourceInfos)84 static void ConvertBundleResourceInfos(
85 napi_env env,
86 const std::vector<BundleResourceInfo> &bundleResourceInfos,
87 napi_value objBundleResourceInfos)
88 {
89 for (size_t index = 0; index < bundleResourceInfos.size(); ++index) {
90 napi_value objBundleResourceInfo = nullptr;
91 napi_create_object(env, &objBundleResourceInfo);
92 ConvertBundleResourceInfo(env, bundleResourceInfos[index], objBundleResourceInfo);
93 napi_set_element(env, objBundleResourceInfos, index, objBundleResourceInfo);
94 }
95 }
96
ConvertLauncherAbilityResourceInfo(napi_env env,const LauncherAbilityResourceInfo & launcherAbilityResourceInfo,napi_value objLauncherAbilityResourceInfo)97 static void ConvertLauncherAbilityResourceInfo(
98 napi_env env,
99 const LauncherAbilityResourceInfo &launcherAbilityResourceInfo,
100 napi_value objLauncherAbilityResourceInfo)
101 {
102 APP_LOGD("start");
103 napi_value nBundleName;
104 NAPI_CALL_RETURN_VOID(
105 env, napi_create_string_utf8(env, launcherAbilityResourceInfo.bundleName.c_str(),
106 NAPI_AUTO_LENGTH, &nBundleName));
107 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo,
108 BUNDLE_NAME, nBundleName));
109
110 napi_value nModuleName;
111 NAPI_CALL_RETURN_VOID(
112 env, napi_create_string_utf8(env, launcherAbilityResourceInfo.moduleName.c_str(),
113 NAPI_AUTO_LENGTH, &nModuleName));
114 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo,
115 MODULE_NAME, nModuleName));
116
117 napi_value nAbilityName;
118 NAPI_CALL_RETURN_VOID(
119 env, napi_create_string_utf8(env, launcherAbilityResourceInfo.abilityName.c_str(),
120 NAPI_AUTO_LENGTH, &nAbilityName));
121 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo,
122 ABILITY_NAME, nAbilityName));
123
124 napi_value nLabel;
125 NAPI_CALL_RETURN_VOID(
126 env, napi_create_string_utf8(env, launcherAbilityResourceInfo.label.c_str(),
127 NAPI_AUTO_LENGTH, &nLabel));
128 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo,
129 LABEL, nLabel));
130
131 napi_value nIcon;
132 NAPI_CALL_RETURN_VOID(
133 env, napi_create_string_utf8(env, launcherAbilityResourceInfo.icon.c_str(),
134 NAPI_AUTO_LENGTH, &nIcon));
135 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo,
136 ICON, nIcon));
137
138 napi_value nDrawableDescriptor = BundleResourceDrawableUtils::ConvertToDrawableDescriptor(
139 env, launcherAbilityResourceInfo.foreground, launcherAbilityResourceInfo.background);
140 if (nDrawableDescriptor == nullptr) {
141 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nDrawableDescriptor));
142 }
143 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo,
144 DRAWABLE_DESCRIPTOR, nDrawableDescriptor));
145
146 napi_value nAppIndex;
147 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbilityResourceInfo.appIndex, &nAppIndex));
148 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objLauncherAbilityResourceInfo, APP_INDEX, nAppIndex));
149 APP_LOGD("end");
150 }
151
ConvertLauncherAbilityResourceInfos(napi_env env,const std::vector<LauncherAbilityResourceInfo> & launcherAbilityResourceInfos,napi_value objLauncherAbilityResourceInfos)152 static void ConvertLauncherAbilityResourceInfos(
153 napi_env env,
154 const std::vector<LauncherAbilityResourceInfo> &launcherAbilityResourceInfos,
155 napi_value objLauncherAbilityResourceInfos)
156 {
157 for (size_t index = 0; index < launcherAbilityResourceInfos.size(); ++index) {
158 napi_value objLauncherAbilityResourceInfo = nullptr;
159 napi_create_object(env, &objLauncherAbilityResourceInfo);
160 ConvertLauncherAbilityResourceInfo(env, launcherAbilityResourceInfos[index], objLauncherAbilityResourceInfo);
161 napi_set_element(env, objLauncherAbilityResourceInfos, index, objLauncherAbilityResourceInfo);
162 }
163 }
164 }
165
GetBundleResourceInfo(napi_env env,napi_callback_info info)166 napi_value GetBundleResourceInfo(napi_env env, napi_callback_info info)
167 {
168 APP_LOGI("NAPI start");
169 NapiArg args(env, info);
170 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
171 APP_LOGE("param count invalid");
172 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
173 return nullptr;
174 }
175 std::string bundleName;
176 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName) || bundleName.empty()) {
177 APP_LOGE("parse bundleName failed, bundleName is %{public}s", bundleName.c_str());
178 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
179 return nullptr;
180 }
181 int32_t flags = 0;
182 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
183 if (!CommonFunc::ParseInt(env, args[ARGS_POS_ONE], flags)) {
184 APP_LOGW("parse flags failed");
185 }
186 }
187 if (flags <= 0) {
188 flags = static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
189 }
190 int32_t appIndex = 0;
191 if (args.GetMaxArgc() >= ARGS_SIZE_THREE) {
192 if (!CommonFunc::ParseInt(env, args[ARGS_POS_TWO], appIndex)) {
193 APP_LOGW("parse appIndex failed");
194 }
195 }
196 BundleResourceInfo resourceInfo;
197 auto ret = ResourceHelper::InnerGetBundleResourceInfo(bundleName, flags, appIndex, resourceInfo);
198 if (ret != ERR_OK) {
199 napi_value businessError = BusinessError::CreateCommonError(
200 env, ret, GET_BUNDLE_RESOURCE_INFO, PERMISSION_GET_BUNDLE_RESOURCES);
201 napi_throw(env, businessError);
202 return nullptr;
203 }
204 napi_value nBundleResourceInfo = nullptr;
205 NAPI_CALL(env, napi_create_object(env, &nBundleResourceInfo));
206 ConvertBundleResourceInfo(env, resourceInfo, nBundleResourceInfo);
207 APP_LOGI("NAPI end");
208 return nBundleResourceInfo;
209 }
210
GetLauncherAbilityResourceInfo(napi_env env,napi_callback_info info)211 napi_value GetLauncherAbilityResourceInfo(napi_env env, napi_callback_info info)
212 {
213 APP_LOGD("NAPI start");
214 NapiArg args(env, info);
215 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_THREE)) {
216 APP_LOGE("param count invalid");
217 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
218 return nullptr;
219 }
220 std::string bundleName;
221 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName) || bundleName.empty()) {
222 APP_LOGE("parse bundleName failed, bundleName is %{public}s", bundleName.c_str());
223 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
224 return nullptr;
225 }
226 int32_t flags = 0;
227 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
228 if (!CommonFunc::ParseInt(env, args[ARGS_POS_ONE], flags)) {
229 APP_LOGW("parse flags failed");
230 }
231 }
232 if (flags <= 0) {
233 flags = static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
234 }
235 int32_t appIndex = 0;
236 if (args.GetMaxArgc() >= ARGS_SIZE_THREE) {
237 if (!CommonFunc::ParseInt(env, args[ARGS_POS_TWO], appIndex)) {
238 APP_LOGW("parse appIndex failed");
239 }
240 }
241
242 std::vector<LauncherAbilityResourceInfo> launcherAbilityResourceInfos;
243 auto ret = ResourceHelper::InnerGetLauncherAbilityResourceInfo(
244 bundleName, flags, appIndex, launcherAbilityResourceInfos);
245 if (ret != ERR_OK) {
246 napi_value businessError = BusinessError::CreateCommonError(
247 env, ret, GET_LAUNCHER_ABILITY_RESOURCE_INFO, PERMISSION_GET_BUNDLE_RESOURCES);
248 napi_throw(env, businessError);
249 return nullptr;
250 }
251 napi_value nLauncherAbilityResourceInfos = nullptr;
252 NAPI_CALL(env, napi_create_array(env, &nLauncherAbilityResourceInfos));
253 ConvertLauncherAbilityResourceInfos(env, launcherAbilityResourceInfos, nLauncherAbilityResourceInfos);
254 APP_LOGD("NAPI end");
255 return nLauncherAbilityResourceInfos;
256 }
257
GetAllBundleResourceInfoExec(napi_env env,void * data)258 void GetAllBundleResourceInfoExec(napi_env env, void *data)
259 {
260 AllBundleResourceInfoCallback *asyncCallbackInfo = reinterpret_cast<AllBundleResourceInfoCallback *>(data);
261 if (asyncCallbackInfo == nullptr) {
262 APP_LOGE("asyncCallbackInfo is null");
263 return;
264 }
265 asyncCallbackInfo->err = ResourceHelper::InnerGetAllBundleResourceInfo(asyncCallbackInfo->flags,
266 asyncCallbackInfo->bundleResourceInfos);
267 }
268
GetAllBundleResourceInfoComplete(napi_env env,napi_status status,void * data)269 void GetAllBundleResourceInfoComplete(napi_env env, napi_status status, void *data)
270 {
271 AllBundleResourceInfoCallback *asyncCallbackInfo = reinterpret_cast<AllBundleResourceInfoCallback *>(data);
272 if (asyncCallbackInfo == nullptr) {
273 APP_LOGE("asyncCallbackInfo is null");
274 return;
275 }
276 std::unique_ptr<AllBundleResourceInfoCallback> callbackPtr {asyncCallbackInfo};
277 napi_value result[ARGS_SIZE_TWO] = {0};
278 if (asyncCallbackInfo->err == NO_ERROR) {
279 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
280 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[1]));
281 ConvertBundleResourceInfos(env, asyncCallbackInfo->bundleResourceInfos, result[1]);
282 } else {
283 result[0] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
284 GET_ALL_BUNDLE_RESOURCE_INFO, PERMISSION_GET_ALL_BUNDLE_RESOURCES);
285 }
286 CommonFunc::NapiReturnDeferred<AllBundleResourceInfoCallback>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
287 }
288
GetAllBundleResourceInfo(napi_env env,napi_callback_info info)289 napi_value GetAllBundleResourceInfo(napi_env env, napi_callback_info info)
290 {
291 APP_LOGD("NAPI start");
292 NapiArg args(env, info);
293 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
294 APP_LOGE("param count invalid");
295 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
296 return nullptr;
297 }
298 AllBundleResourceInfoCallback *asyncCallbackInfo = new (std::nothrow) AllBundleResourceInfoCallback(env);
299 if (asyncCallbackInfo == nullptr) {
300 APP_LOGE("asyncCallbackInfo is null");
301 return nullptr;
302 }
303 std::unique_ptr<AllBundleResourceInfoCallback> callbackPtr {asyncCallbackInfo};
304 int32_t flags = 0;
305 if (!CommonFunc::ParseInt(env, args[ARGS_POS_ZERO], flags)) {
306 APP_LOGE("Flags %{public}d invalid", flags);
307 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, RESOURCE_FLAGS, TYPE_NUMBER);
308 return nullptr;
309 }
310 if (flags <= 0) {
311 flags = static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
312 }
313 asyncCallbackInfo->flags = static_cast<uint32_t>(flags);
314 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
315 napi_valuetype valueType = napi_undefined;
316 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
317 if (valueType == napi_function) {
318 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
319 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
320 }
321 }
322 auto promise = CommonFunc::AsyncCallNativeMethod<AllBundleResourceInfoCallback>(
323 env, asyncCallbackInfo, GET_ALL_BUNDLE_RESOURCE_INFO, GetAllBundleResourceInfoExec,
324 GetAllBundleResourceInfoComplete);
325 callbackPtr.release();
326 APP_LOGD("NAPI end");
327 return promise;
328 }
329
GetAllLauncherAbilityResourceInfoExec(napi_env env,void * data)330 void GetAllLauncherAbilityResourceInfoExec(napi_env env, void *data)
331 {
332 AllLauncherAbilityResourceInfoCallback *asyncCallbackInfo =
333 reinterpret_cast<AllLauncherAbilityResourceInfoCallback *>(data);
334 if (asyncCallbackInfo == nullptr) {
335 APP_LOGE("asyncCallbackInfo is null");
336 return;
337 }
338 asyncCallbackInfo->err = ResourceHelper::InnerGetAllLauncherAbilityResourceInfo(
339 asyncCallbackInfo->flags, asyncCallbackInfo->launcherAbilityResourceInfos);
340 }
341
GetAllLauncherAbilityResourceInfoComplete(napi_env env,napi_status status,void * data)342 void GetAllLauncherAbilityResourceInfoComplete(napi_env env, napi_status status, void *data)
343 {
344 AllLauncherAbilityResourceInfoCallback *asyncCallbackInfo =
345 reinterpret_cast<AllLauncherAbilityResourceInfoCallback *>(data);
346 if (asyncCallbackInfo == nullptr) {
347 APP_LOGE("asyncCallbackInfo is null");
348 return;
349 }
350 std::unique_ptr<AllLauncherAbilityResourceInfoCallback> callbackPtr {asyncCallbackInfo};
351 napi_value result[ARGS_SIZE_TWO] = {0};
352 if (asyncCallbackInfo->err == NO_ERROR) {
353 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
354 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[1]));
355 ConvertLauncherAbilityResourceInfos(env, asyncCallbackInfo->launcherAbilityResourceInfos, result[1]);
356 } else {
357 result[0] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
358 GET_ALL_LAUNCHER_ABILITY_RESOURCE_INFO, PERMISSION_GET_ALL_BUNDLE_RESOURCES);
359 }
360 CommonFunc::NapiReturnDeferred<AllLauncherAbilityResourceInfoCallback>(env, asyncCallbackInfo,
361 result, ARGS_SIZE_TWO);
362 }
363
GetAllLauncherAbilityResourceInfo(napi_env env,napi_callback_info info)364 napi_value GetAllLauncherAbilityResourceInfo(napi_env env, napi_callback_info info)
365 {
366 APP_LOGD("NAPI start");
367 NapiArg args(env, info);
368 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
369 APP_LOGE("param count invalid");
370 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
371 return nullptr;
372 }
373 AllLauncherAbilityResourceInfoCallback *asyncCallbackInfo =
374 new (std::nothrow) AllLauncherAbilityResourceInfoCallback(env);
375 if (asyncCallbackInfo == nullptr) {
376 APP_LOGE("asyncCallbackInfo is null");
377 return nullptr;
378 }
379 std::unique_ptr<AllLauncherAbilityResourceInfoCallback> callbackPtr {asyncCallbackInfo};
380 int32_t flags = 0;
381 if (!CommonFunc::ParseInt(env, args[ARGS_POS_ZERO], flags)) {
382 APP_LOGE("Flags %{public}d invalid", flags);
383 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, RESOURCE_FLAGS, TYPE_NUMBER);
384 return nullptr;
385 }
386 if (flags <= 0) {
387 flags = static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
388 }
389 asyncCallbackInfo->flags = static_cast<uint32_t>(flags);
390 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
391 napi_valuetype valueType = napi_undefined;
392 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
393 if (valueType == napi_function) {
394 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
395 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
396 }
397 }
398 auto promise = CommonFunc::AsyncCallNativeMethod<AllLauncherAbilityResourceInfoCallback>(
399 env, asyncCallbackInfo, GET_ALL_LAUNCHER_ABILITY_RESOURCE_INFO, GetAllLauncherAbilityResourceInfoExec,
400 GetAllLauncherAbilityResourceInfoComplete);
401 callbackPtr.release();
402 APP_LOGD("NAPI end");
403 return promise;
404 }
405
CreateBundleResourceFlagObject(napi_env env,napi_value value)406 void CreateBundleResourceFlagObject(napi_env env, napi_value value)
407 {
408 napi_value nGetAll;
409 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
410 env, static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL), &nGetAll));
411 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, GET_RESOURCE_INFO_ALL, nGetAll));
412
413 napi_value nGetLabel;
414 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
415 env, static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_LABEL), &nGetLabel));
416 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, GET_RESOURCE_INFO_WITH_LABEL, nGetLabel));
417
418 napi_value nGetIcon;
419 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
420 env, static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_ICON), &nGetIcon));
421 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, GET_RESOURCE_INFO_WITH_ICON, nGetIcon));
422
423 napi_value nGetSortByLabel;
424 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
425 env, static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL), &nGetSortByLabel));
426 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value,
427 GET_RESOURCE_INFO_WITH_SORTED_BY_LABEL, nGetSortByLabel));
428
429 napi_value nGetDrawable;
430 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
431 env, static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR), &nGetDrawable));
432 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value,
433 GET_RESOURCE_INFO_WITH_DRAWABLE_DESCRIPTOR, nGetDrawable));
434
435 napi_value nGetMainAbility;
436 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
437 env, static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ONLY_WITH_MAIN_ABILITY), &nGetMainAbility));
438 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value,
439 GET_RESOURCE_INFO_ONLY_WITH_MAIN_ABILITY, nGetMainAbility));
440 }
441
GetExtensionAbilityResourceInfo(napi_env env,napi_callback_info info)442 napi_value GetExtensionAbilityResourceInfo(napi_env env, napi_callback_info info)
443 {
444 APP_LOGD("GetExtensionAbilityResourceInfo start");
445 NapiArg args(env, info);
446 if (!args.Init(ARGS_SIZE_THREE, ARGS_SIZE_FOUR)) {
447 APP_LOGE("param count invalid");
448 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
449 return nullptr;
450 }
451 std::string bundleName;
452 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], bundleName)) {
453 APP_LOGE("parse bundleName failed, bundleName is %{public}s", bundleName.c_str());
454 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
455 return nullptr;
456 }
457 if (bundleName.empty()) {
458 APP_LOGE("invalid bundleName");
459 napi_value businessError = BusinessError::CreateCommonError(env, ERROR_BUNDLE_NOT_EXIST,
460 GET_EXTENSION_ABILITY_RESOURCE_INFO, PERMISSION_GET_BUNDLE_RESOURCES);
461 napi_throw(env, businessError);
462 return nullptr;
463 }
464 int32_t extensionAbilityType = static_cast<int32_t>(ExtensionAbilityType::UNSPECIFIED);
465 if (!CommonFunc::ParseInt(env, args[ARGS_POS_ONE], extensionAbilityType)) {
466 APP_LOGE("parse extensionAbilityType failed");
467 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, EXTENSION_ABILITY_TYPE, TYPE_NUMBER);
468 return nullptr;
469 }
470 int32_t flags = 0;
471 if (!CommonFunc::ParseInt(env, args[ARGS_POS_TWO], flags)) {
472 APP_LOGE("parse flags failed");
473 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, RESOURCE_FLAGS, TYPE_NUMBER);
474 return nullptr;
475 }
476 if (flags <= 0) {
477 flags = static_cast<int32_t>(ResourceFlag::GET_RESOURCE_INFO_ALL);
478 }
479 int32_t appIndex = 0;
480 if (args.GetMaxArgc() >= ARGS_SIZE_FOUR) {
481 if (!CommonFunc::ParseInt(env, args[ARGS_POS_THREE], appIndex)) {
482 APP_LOGW("parse appIndex failed");
483 }
484 }
485 std::vector<LauncherAbilityResourceInfo> entensionAbilityResourceInfos;
486 auto ret = ResourceHelper::InnerGetExtensionAbilityResourceInfo(bundleName,
487 static_cast<ExtensionAbilityType>(extensionAbilityType), flags, appIndex, entensionAbilityResourceInfos);
488 if (ret != ERR_OK) {
489 napi_value businessError = BusinessError::CreateCommonError(
490 env, ret, GET_EXTENSION_ABILITY_RESOURCE_INFO, PERMISSION_GET_BUNDLE_RESOURCES);
491 napi_throw(env, businessError);
492 return nullptr;
493 }
494 napi_value nExtensionAbilityResourceInfos = nullptr;
495 NAPI_CALL(env, napi_create_array(env, &nExtensionAbilityResourceInfos));
496 ConvertLauncherAbilityResourceInfos(env, entensionAbilityResourceInfos, nExtensionAbilityResourceInfos);
497 APP_LOGD("GetExtensionAbilityResourceInfo end");
498 return nExtensionAbilityResourceInfos;
499 }
500
501 } // AppExecFwk
502 } // OHOS
503