1 /*
2 * Copyright (c) 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 <charconv>
17 #include <vector>
18
19 #include "app_log_wrapper.h"
20 #include "common_fun_ani.h"
21
22 namespace OHOS {
23 namespace AppExecFwk {
24 using Want = OHOS::AAFwk::Want;
25 namespace {
26 constexpr const char* CLASSNAME_ABILITYINFO = "LbundleManager/AbilityInfoInner/AbilityInfoInner;";
27 constexpr const char* CLASSNAME_EXTENSIONABILITYINFO =
28 "LbundleManager/ExtensionAbilityInfoInner/ExtensionAbilityInfoInner;";
29 constexpr const char* CLASSNAME_WINDOWSIZE = "LbundleManager/AbilityInfoInner/WindowSizeInner;";
30 constexpr const char* CLASSNAME_APPLICATIONINFO = "LbundleManager/ApplicationInfoInner/ApplicationInfoInner;";
31 constexpr const char* CLASSNAME_MODULEMETADATA = "LbundleManager/ApplicationInfoInner/ModuleMetadataInner;";
32 constexpr const char* CLASSNAME_MULTIAPPMODE = "LbundleManager/ApplicationInfoInner/MultiAppModeInner;";
33 constexpr const char* CLASSNAME_BUNDLEINFO = "LbundleManager/BundleInfoInner/BundleInfoInner;";
34 constexpr const char* CLASSNAME_PERMISSION = "LbundleManager/BundleInfoInner/ReqPermissionDetailInner;";
35 constexpr const char* CLASSNAME_USEDSCENE = "LbundleManager/BundleInfoInner/UsedSceneInner;";
36 constexpr const char* CLASSNAME_SIGNATUREINFO = "LbundleManager/BundleInfoInner/SignatureInfoInner;";
37 constexpr const char* CLASSNAME_APPCLONEIDENTITY = "LbundleManager/BundleInfoInner/AppCloneIdentityInner;";
38 constexpr const char* CLASSNAME_METADATA = "LbundleManager/MetadataInner/MetadataInner;";
39 constexpr const char* CLASSNAME_RESOURCE = "Lglobal/resourceInner/ResourceInner;";
40 constexpr const char* CLASSNAME_ROUTERITEM = "LbundleManager/HapModuleInfoInner/RouterItemInner;";
41 constexpr const char* CLASSNAME_PRELOADITEM = "LbundleManager/HapModuleInfoInner/PreloadItemInner;";
42 constexpr const char* CLASSNAME_DEPENDENCY = "LbundleManager/HapModuleInfoInner/DependencyInner;";
43 constexpr const char* CLASSNAME_HAPMODULEINFO = "LbundleManager/HapModuleInfoInner/HapModuleInfoInner;";
44 constexpr const char* CLASSNAME_DATAITEM = "LbundleManager/HapModuleInfoInner/DataItemInner;";
45 constexpr const char* CLASSNAME_ELEMENTNAME = "LbundleManager/ElementNameInner/ElementNameInner;";
46 constexpr const char* CLASSNAME_SKILL = "LbundleManager/SkillInner/SkillInner;";
47 constexpr const char* CLASSNAME_SKILLURI = "LbundleManager/SkillInner/SkillUriInner;";
48 constexpr const char* CLASSNAME_BUNDLERESINFO = "LbundleManager/BundleResourceInfoInner/BundleResourceInfoInner;";
49 constexpr const char* CLASSNAME_LAUNCHER_ABILITY_RESOURCE_INFO_INNER =
50 "LbundleManager/LauncherAbilityResourceInfoInner/LauncherAbilityResourceInfoInner;";
51 constexpr const char* CLASSNAME_SHORTCUTINFO = "LbundleManager/ShortcutInfo/ShortcutInfoInner;";
52 constexpr const char* CLASSNAME_SHORTCUTWANT = "LbundleManager/ShortcutInfo/ShortcutWantInner;";
53 constexpr const char* CLASSNAME_SHORTCUT_PARAMETERITEM = "LbundleManager/ShortcutInfo/ParameterItemInner;";
54 constexpr const char* CLASSNAME_LAUNCHER_ABILITY_INFO_INNER =
55 "LbundleManager/LauncherAbilityInfoInner/LauncherAbilityInfoInner;";
56 constexpr const char* CLASSNAME_BUNDLE_CHANGED_INFO_INNER =
57 "L@ohos/bundle/bundleMonitor/bundleMonitor/BundleChangedInfoInner;";
58 constexpr const char* CLASSNAME_BUNDLE_PACK_INFO_INNER = "LbundleManager/BundlePackInfoInner/BundlePackInfoInner;";
59 constexpr const char* CLASSNAME_PACKAGE_CONFIG_INNER = "LbundleManager/BundlePackInfoInner/PackageConfigInner;";
60 constexpr const char* CLASSNAME_PACKAGE_SUMMARY_INNER = "LbundleManager/BundlePackInfoInner/PackageSummaryInner;";
61 constexpr const char* CLASSNAME_BUNDLE_CONFIG_INFO_INNER = "LbundleManager/BundlePackInfoInner/BundleConfigInfoInner;";
62 constexpr const char* CLASSNAME_EXTENSION_ABILITY_INNER = "LbundleManager/BundlePackInfoInner/ExtensionAbilityInner;";
63 constexpr const char* CLASSNAME_MODULE_CONFIG_INFO_INNER = "LbundleManager/BundlePackInfoInner/ModuleConfigInfoInner;";
64 constexpr const char* CLASSNAME_MODULE_DISTRO_INFO_INNER = "LbundleManager/BundlePackInfoInner/ModuleDistroInfoInner;";
65 constexpr const char* CLASSNAME_MODULE_ABILITY_INFO_INNER =
66 "LbundleManager/BundlePackInfoInner/ModuleAbilityInfoInner;";
67 constexpr const char* CLASSNAME_ABILITY_FORM_INFO_INNER = "LbundleManager/BundlePackInfoInner/AbilityFormInfoInner;";
68 constexpr const char* CLASSNAME_VERSION_INNER = "LbundleManager/BundlePackInfoInner/VersionInner;";
69 constexpr const char* CLASSNAME_API_VERSION_INNER = "LbundleManager/BundlePackInfoInner/ApiVersionInner;";
70 constexpr const char* CLASSNAME_DISPATCH_INFO_INNER = "LbundleManager/DispatchInfoInner/DispatchInfoInner;";
71 constexpr const char* CLASSNAME_OVERLAY_MOUDLE_INFO_INNER =
72 "LbundleManager/OverlayModuleInfoInner/OverlayModuleInfoInner;";
73 constexpr const char* CLASSNAME_WANT = "L@ohos/app/ability/Want/Want;";
74
75 constexpr const char* PROPERTYNAME_NAME = "name";
76 constexpr const char* PROPERTYNAME_VENDOR = "vendor";
77 constexpr const char* PROPERTYNAME_VERSIONCODE = "versionCode";
78 constexpr const char* PROPERTYNAME_VERSIONNAME = "versionName";
79 constexpr const char* PROPERTYNAME_MINCOMPATIBLEVERSIONCODE = "minCompatibleVersionCode";
80 constexpr const char* PROPERTYNAME_TARGETVERSION = "targetVersion";
81 constexpr const char* PROPERTYNAME_APPINFO = "appInfo";
82 constexpr const char* PROPERTYNAME_HAPMODULESINFO = "hapModulesInfo";
83 constexpr const char* PROPERTYNAME_REQPERMISSIONDETAILS = "reqPermissionDetails";
84 constexpr const char* PROPERTYNAME_PERMISSIONGRANTSTATES = "permissionGrantStates";
85 constexpr const char* PROPERTYNAME_SIGNATUREINFO = "signatureInfo";
86 constexpr const char* PROPERTYNAME_INSTALLTIME = "installTime";
87 constexpr const char* PROPERTYNAME_UPDATETIME = "updateTime";
88 constexpr const char* PROPERTYNAME_FIRSTINSTALLTIME = "firstInstallTime";
89 constexpr const char* PROPERTYNAME_ROUTERMAP = "routerMap";
90 constexpr const char* PROPERTYNAME_APPINDEX = "appIndex";
91 constexpr const char* PROPERTYNAME_KEY = "key";
92 constexpr const char* PROPERTYNAME_VALUE = "value";
93 constexpr const char* PROPERTYNAME_RESOURCE = "resource";
94 constexpr const char* PROPERTYNAME_VALUEID = "valueId";
95 constexpr const char* PROPERTYNAME_MAXCOUNT = "maxCount";
96 constexpr const char* PROPERTYNAME_MULTIAPPMODETYPE = "multiAppModeType";
97 constexpr const char* PROPERTYNAME_MODULENAME = "moduleName";
98 constexpr const char* PROPERTYNAME_METADATA = "metadata";
99 constexpr const char* PROPERTYNAME_DESCRIPTION = "description";
100 constexpr const char* PROPERTYNAME_DESCRIPTIONID = "descriptionId";
101 constexpr const char* PROPERTYNAME_ENABLED = "enabled";
102 constexpr const char* PROPERTYNAME_LABEL = "label";
103 constexpr const char* PROPERTYNAME_LABELID = "labelId";
104 constexpr const char* PROPERTYNAME_ICON = "icon";
105 constexpr const char* PROPERTYNAME_ICONID = "iconId";
106 constexpr const char* PROPERTYNAME_PROCESS = "process";
107 constexpr const char* PROPERTYNAME_PERMISSIONS = "permissions";
108 constexpr const char* PROPERTYNAME_CODEPATH = "codePath";
109 constexpr const char* PROPERTYNAME_METADATAARRAY = "metadataArray";
110 constexpr const char* PROPERTYNAME_REMOVABLE = "removable";
111 constexpr const char* PROPERTYNAME_ACCESSTOKENID = "accessTokenId";
112 constexpr const char* PROPERTYNAME_UID = "uid";
113 constexpr const char* PROPERTYNAME_ICONRESOURCE = "iconResource";
114 constexpr const char* PROPERTYNAME_LABELRESOURCE = "labelResource";
115 constexpr const char* PROPERTYNAME_DESCRIPTIONRESOURCE = "descriptionResource";
116 constexpr const char* PROPERTYNAME_APPDISTRIBUTIONTYPE = "appDistributionType";
117 constexpr const char* PROPERTYNAME_APPPROVISIONTYPE = "appProvisionType";
118 constexpr const char* PROPERTYNAME_SYSTEMAPP = "systemApp";
119 constexpr const char* PROPERTYNAME_BUNDLETYPE = "bundleType";
120 constexpr const char* PROPERTYNAME_DEBUG = "debug";
121 constexpr const char* PROPERTYNAME_DATAUNCLEARABLE = "dataUnclearable";
122 constexpr const char* PROPERTYNAME_NATIVELIBRARYPATH = "nativeLibraryPath";
123 constexpr const char* PROPERTYNAME_MULTIAPPMODE = "multiAppMode";
124 constexpr const char* PROPERTYNAME_INSTALLSOURCE = "installSource";
125 constexpr const char* PROPERTYNAME_RELEASETYPE = "releaseType";
126 constexpr const char* PROPERTYNAME_CLOUDFILESYNCENABLED = "cloudFileSyncEnabled";
127 constexpr const char* PROPERTYNAME_CLOUDSTRUCTUREDDATASYNCENABLED = "cloudStructuredDataSyncEnabled";
128 constexpr const char* PROPERTYNAME_FLAGS = "flags";
129 constexpr const char* PROPERTYNAME_BUNDLENAME = "bundleName";
130 constexpr const char* PROPERTYNAME_EXPORTED = "exported";
131 constexpr const char* PROPERTYNAME_TYPE = "type";
132 constexpr const char* PROPERTYNAME_ORIENTATION = "orientation";
133 constexpr const char* PROPERTYNAME_LAUNCHTYPE = "launchType";
134 constexpr const char* PROPERTYNAME_READPERMISSION = "readPermission";
135 constexpr const char* PROPERTYNAME_WRITEPERMISSION = "writePermission";
136 constexpr const char* PROPERTYNAME_URI = "uri";
137 constexpr const char* PROPERTYNAME_DEVICETYPES = "deviceTypes";
138 constexpr const char* PROPERTYNAME_APPLICATIONINFO = "applicationInfo";
139 constexpr const char* PROPERTYNAME_SUPPORTWINDOWMODES = "supportWindowModes";
140 constexpr const char* PROPERTYNAME_WINDOWSIZE = "windowSize";
141 constexpr const char* PROPERTYNAME_EXCLUDEFROMDOCK = "excludeFromDock";
142 constexpr const char* PROPERTYNAME_SKILLS = "skills";
143 constexpr const char* PROPERTYNAME_ORIENTATIONID = "orientationId";
144 constexpr const char* PROPERTYNAME_MAXWINDOWRATIO = "maxWindowRatio";
145 constexpr const char* PROPERTYNAME_MINWINDOWRATIO = "minWindowRatio";
146 constexpr const char* PROPERTYNAME_MAXWINDOWWIDTH = "maxWindowWidth";
147 constexpr const char* PROPERTYNAME_MINWINDOWWIDTH = "minWindowWidth";
148 constexpr const char* PROPERTYNAME_MAXWINDOWHEIGHT = "maxWindowHeight";
149 constexpr const char* PROPERTYNAME_MINWINDOWHEIGHT = "minWindowHeight";
150 constexpr const char* PROPERTYNAME_EXTENSIONABILITYTYPE = "extensionAbilityType";
151 constexpr const char* PROPERTYNAME_EXTENSIONABILITYTYPENAME = "extensionAbilityTypeName";
152 constexpr const char* PROPERTYNAME_ID = "id";
153 constexpr const char* PROPERTYNAME_APPID = "appId";
154 constexpr const char* PROPERTYNAME_FINGERPRINT = "fingerprint";
155 constexpr const char* PROPERTYNAME_APPIDENTIFIER = "appIdentifier";
156 constexpr const char* PROPERTYNAME_CERTIFICATE = "certificate";
157 constexpr const char* PROPERTYNAME_PAGESOURCEFILE = "pageSourceFile";
158 constexpr const char* PROPERTYNAME_BUILDFUNCTION = "buildFunction";
159 constexpr const char* PROPERTYNAME_CUSTOMDATA = "customData";
160 constexpr const char* PROPERTYNAME_DATA = "data";
161 constexpr const char* PROPERTYNAME_REASON = "reason";
162 constexpr const char* PROPERTYNAME_REASONID = "reasonId";
163 constexpr const char* PROPERTYNAME_USEDSCENE = "usedScene";
164 constexpr const char* PROPERTYNAME_WHEN = "when";
165 constexpr const char* PROPERTYNAME_ABILITIES = "abilities";
166 constexpr const char* PROPERTYNAME_MAINELEMENTNAME = "mainElementName";
167 constexpr const char* PROPERTYNAME_ABILITIESINFO = "abilitiesInfo";
168 constexpr const char* PROPERTYNAME_EXTENSIONABILITIESINFO = "extensionAbilitiesInfo";
169 constexpr const char* PROPERTYNAME_INSTALLATIONFREE = "installationFree";
170 constexpr const char* PROPERTYNAME_HASHVALUE = "hashValue";
171 constexpr const char* PROPERTYNAME_DEPENDENCIES = "dependencies";
172 constexpr const char* PROPERTYNAME_PRELOADS = "preloads";
173 constexpr const char* PROPERTYNAME_FILECONTEXTMENUCONFIG = "fileContextMenuConfig";
174 constexpr const char* PROPERTYNAME_DEVICEID = "deviceId";
175 constexpr const char* PROPERTYNAME_ABILITYNAME = "abilityName";
176 constexpr const char* PROPERTYNAME_SHORTNAME = "shortName";
177 constexpr const char* PROPERTYNAME_SCHEME = "scheme";
178 constexpr const char* PROPERTYNAME_HOST = "host";
179 constexpr const char* PROPERTYNAME_PORT = "port";
180 constexpr const char* PROPERTYNAME_PATH = "path";
181 constexpr const char* PROPERTYNAME_PATHSTARTWITH = "pathStartWith";
182 constexpr const char* PROPERTYNAME_PATHREGEX = "pathRegex";
183 constexpr const char* PROPERTYNAME_UTD = "utd";
184 constexpr const char* PROPERTYNAME_MAXFILESUPPORTED = "maxFileSupported";
185 constexpr const char* PROPERTYNAME_LINKFEATURE = "linkFeature";
186 constexpr const char* PROPERTYNAME_ACTIONS = "actions";
187 constexpr const char* PROPERTYNAME_ENTITIES = "entities";
188 constexpr const char* PROPERTYNAME_URIS = "uris";
189 constexpr const char* PROPERTYNAME_DOMAINVERIFY = "domainVerify";
190 constexpr const char* PROPERTYNAME_HOSTABILITY = "hostAbility";
191 constexpr const char* PROPERTYNAME_WANTS = "wants";
192 constexpr const char* PROPERTYNAME_SOURCETYPE = "sourceType";
193 constexpr const char* PROPERTYNAME_TARGETBUNDLE = "targetBundle";
194 constexpr const char* PROPERTYNAME_TARGETMODULE = "targetModule";
195 constexpr const char* PROPERTYNAME_TARGETABILITY = "targetAbility";
196 constexpr const char* PROPERTYNAME_PARAMETERS = "parameters";
197 constexpr const char* PROPERTYNAME_ELEMENTNAME = "elementName";
198 constexpr const char* PROPERTYNAME_USERID = "userId";
199 constexpr const char* PROPERTYNAME_HASHPARAMS = "hashParams";
200 constexpr const char* PROPERTYNAME_PGOFILEPATH = "pgoFilePath";
201 constexpr const char* PROPERTYNAME_PGOPARAMS = "pgoParams";
202 constexpr const char* PROPERTYNAME_SPECIFIEDDISTRIBUTIONTYPE = "specifiedDistributionType";
203 constexpr const char* PROPERTYNAME_ISKEEPDATA = "isKeepData";
204 constexpr const char* PROPERTYNAME_INSTALLFLAG = "installFlag";
205 constexpr const char* PROPERTYNAME_CROWDTESTDEADLINE = "crowdtestDeadline";
206 constexpr const char* PROPERTYNAME_SHAREDBUNDLEDIRPATHS = "sharedBundleDirPaths";
207 constexpr const char* PROPERTYNAME_ADDITIONALINFO = "additionalInfo";
208 constexpr const char* PROPERTYNAME_CODE = "code";
209 constexpr const char* PROPERTYNAME_VERSION = "version";
210 constexpr const char* PROPERTYNAME_UPDATEENABLED = "updateEnabled";
211 constexpr const char* PROPERTYNAME_SCHEDULEDUPDATETIME = "scheduledUpdateTime";
212 constexpr const char* PROPERTYNAME_UPDATEDURATION = "updateDuration";
213 constexpr const char* PROPERTYNAME_SUPPORTDIMENSIONS = "supportDimensions";
214 constexpr const char* PROPERTYNAME_DEFAULTDIMENSION = "defaultDimension";
215 constexpr const char* PROPERTYNAME_FORMS = "forms";
216 constexpr const char* PROPERTYNAME_DELIVERYWITHINSTALL = "deliveryWithInstall";
217 constexpr const char* PROPERTYNAME_MODULETYPE = "moduleType";
218 constexpr const char* PROPERTYNAME_COMPATIBLE = "compatible";
219 constexpr const char* PROPERTYNAME_TARGET = "target";
220 constexpr const char* PROPERTYNAME_MAINABILITY = "mainAbility";
221 constexpr const char* PROPERTYNAME_APIVERSION = "apiVersion";
222 constexpr const char* PROPERTYNAME_DISTRO = "distro";
223 constexpr const char* PROPERTYNAME_EXTENSIONABILITIES = "extensionAbilities";
224 constexpr const char* PROPERTYNAME_APP = "app";
225 constexpr const char* PROPERTYNAME_MODULES = "modules";
226 constexpr const char* PROPERTYNAME_PACKAGES = "packages";
227 constexpr const char* PROPERTYNAME_SUMMARY = "summary";
228 constexpr const char* PROPERTYNAME_DISPATCHAPIVERSION = "dispatchAPIVersion";
229 constexpr const char* PROPERTYNAME_TARGETMOUDLENAME = "targetModuleName";
230 constexpr const char* PROPERTYNAME_PRIORITY = "priority";
231 constexpr const char* PROPERTYNAME_STATE = "state";
232 constexpr const char* PROPERTYNAME_VISIBLE = "visible";
233 constexpr const char* PROPERTYNAME_ACTION = "action";
234
235 constexpr const char* PATH_PREFIX = "/data/app/el1/bundle/public";
236 constexpr const char* CODE_PATH_PREFIX = "/data/storage/el1/bundle/";
237 constexpr const char* CONTEXT_DATA_STORAGE_BUNDLE = "/data/storage/el1/bundle/";
238 } // namespace
239
AniStrToString(ani_env * env,ani_string aniStr)240 std::string CommonFunAni::AniStrToString(ani_env* env, ani_string aniStr)
241 {
242 if (env == nullptr || aniStr == nullptr) {
243 APP_LOGE("env or aniStr is null");
244 return "";
245 }
246
247 ani_size strSize = 0;
248 ani_status status = env->String_GetUTF8Size(aniStr, &strSize);
249 if (status != ANI_OK) {
250 APP_LOGE("String_GetUTF8Size failed %{public}d", status);
251 return "";
252 }
253
254 std::string buffer;
255 buffer.resize(strSize + 1);
256 ani_size retSize = 0;
257 status = env->String_GetUTF8(aniStr, buffer.data(), buffer.size(), &retSize);
258 if (status != ANI_OK || retSize == 0) {
259 APP_LOGE("String_GetUTF8SubString failed %{public}d", status);
260 return "";
261 }
262
263 buffer.resize(retSize);
264 return buffer;
265 }
266
ParseString(ani_env * env,ani_string aniStr,std::string & result)267 bool CommonFunAni::ParseString(ani_env* env, ani_string aniStr, std::string& result)
268 {
269 RETURN_FALSE_IF_NULL(env);
270 RETURN_FALSE_IF_NULL(aniStr);
271
272 ani_size strSize = 0;
273 ani_status status = env->String_GetUTF8Size(aniStr, &strSize);
274 if (status != ANI_OK) {
275 APP_LOGE("String_GetUTF8Size failed %{public}d", status);
276 return false;
277 }
278
279 result.resize(strSize + 1);
280 ani_size retSize = 0;
281 status = env->String_GetUTF8(aniStr, result.data(), result.size(), &retSize);
282 if (status != ANI_OK) {
283 APP_LOGE("String_GetUTF8SubString failed %{public}d", status);
284 return false;
285 }
286
287 result.resize(retSize);
288 return true;
289 }
290
CreateClassByName(ani_env * env,const std::string & className)291 ani_class CommonFunAni::CreateClassByName(ani_env* env, const std::string& className)
292 {
293 RETURN_NULL_IF_NULL(env);
294
295 ani_class cls = nullptr;
296 ani_status status = env->FindClass(className.c_str(), &cls);
297 if (status != ANI_OK) {
298 APP_LOGE("FindClass failed %{public}d", status);
299 return nullptr;
300 }
301 return cls;
302 }
303
CreateNewObjectByClass(ani_env * env,ani_class cls)304 ani_object CommonFunAni::CreateNewObjectByClass(ani_env* env, ani_class cls)
305 {
306 RETURN_NULL_IF_NULL(env);
307
308 ani_method method = nullptr;
309 ani_status status = env->Class_FindMethod(cls, "<ctor>", ":V", &method);
310 if (status != ANI_OK) {
311 APP_LOGE("Class_FindMethod failed %{public}d", status);
312 return nullptr;
313 }
314
315 ani_object object = nullptr;
316 status = env->Object_New(cls, method, &object);
317 if (status != ANI_OK) {
318 APP_LOGE("Object_New failed %{public}d", status);
319 return nullptr;
320 }
321 return object;
322 }
323
ConvertBundleInfo(ani_env * env,const BundleInfo & bundleInfo,int32_t flags)324 ani_object CommonFunAni::ConvertBundleInfo(ani_env* env, const BundleInfo& bundleInfo, int32_t flags)
325 {
326 RETURN_NULL_IF_NULL(env);
327
328 ani_class cls = CreateClassByName(env, CLASSNAME_BUNDLEINFO);
329 RETURN_NULL_IF_NULL(cls);
330
331 ani_object object = CreateNewObjectByClass(env, cls);
332 RETURN_NULL_IF_NULL(object);
333
334 ani_string string = nullptr;
335
336 // name: string
337 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleInfo.name, string));
338 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
339
340 // vendor: string
341 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleInfo.vendor, string));
342 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VENDOR, string));
343
344 // versionCode: number
345 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VERSIONCODE, bundleInfo.versionCode));
346
347 // versionName: string
348 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleInfo.versionName, string));
349 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VERSIONNAME, string));
350
351 // minCompatibleVersionCode: number
352 RETURN_NULL_IF_FALSE(
353 CallSetter(env, cls, object, PROPERTYNAME_MINCOMPATIBLEVERSIONCODE, bundleInfo.minCompatibleVersionCode));
354
355 // targetVersion: number
356 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TARGETVERSION, bundleInfo.targetVersion));
357
358 // appInfo: ApplicationInfo
359 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) ==
360 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
361 ani_object aObject = ConvertApplicationInfo(env, bundleInfo.applicationInfo);
362 RETURN_NULL_IF_NULL(aObject);
363 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINFO, aObject));
364 } else {
365 RETURN_NULL_IF_FALSE(CallSetterNull(env, cls, object, PROPERTYNAME_APPINFO));
366 }
367
368 // hapModulesInfo: Array<HapModuleInfo>
369 ani_object aHapModuleInfosObject = ConvertAniArray(env, bundleInfo.hapModuleInfos, ConvertHapModuleInfo);
370 RETURN_NULL_IF_NULL(aHapModuleInfosObject);
371 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_HAPMODULESINFO, aHapModuleInfosObject));
372
373 // reqPermissionDetails: Array<ReqPermissionDetail>
374 ani_object aPermissionArrayObject = ConvertAniArray(env, bundleInfo.reqPermissionDetails, ConvertRequestPermission);
375 RETURN_NULL_IF_NULL(aPermissionArrayObject);
376 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_REQPERMISSIONDETAILS, aPermissionArrayObject));
377
378 // permissionGrantStates: Array<bundleManager.PermissionGrantState>
379 ani_object aPermissionGrantStates = ConvertAniArrayEnum(
380 env, bundleInfo.reqPermissionStates, EnumUtils::EnumNativeToETS_BundleManager_PermissionGrantState);
381 RETURN_NULL_IF_NULL(aPermissionGrantStates);
382 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PERMISSIONGRANTSTATES, aPermissionGrantStates));
383
384 // signatureInfo: SignatureInfo
385 if ((static_cast<uint32_t>(flags) &
386 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) ==
387 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
388 ani_object aniSignatureInfoObj = ConvertSignatureInfo(env, bundleInfo.signatureInfo);
389 RETURN_NULL_IF_NULL(aniSignatureInfoObj);
390 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SIGNATUREINFO, aniSignatureInfoObj));
391 } else {
392 RETURN_NULL_IF_FALSE(CallSetterNull(env, cls, object, PROPERTYNAME_SIGNATUREINFO));
393 }
394
395 // installTime: number
396 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_INSTALLTIME, bundleInfo.installTime));
397
398 // updateTime: number
399 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_UPDATETIME, bundleInfo.updateTime));
400
401 // routerMap: Array<RouterItem>
402 ani_object aRouterMapObject = ConvertAniArray(env, bundleInfo.routerArray, ConvertRouterItem);
403 RETURN_NULL_IF_NULL(aRouterMapObject);
404 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ROUTERMAP, aRouterMapObject));
405
406 // appIndex: number
407 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, bundleInfo.appIndex));
408
409 // firstInstallTime?: number
410 RETURN_NULL_IF_FALSE(
411 CallSetterOptional(env, cls, object, PROPERTYNAME_FIRSTINSTALLTIME, bundleInfo.firstInstallTime));
412
413 return object;
414 }
415
ConvertMetadata(ani_env * env,const Metadata & metadata)416 ani_object CommonFunAni::ConvertMetadata(ani_env* env, const Metadata& metadata)
417 {
418 RETURN_NULL_IF_NULL(env);
419
420 ani_class cls = CreateClassByName(env, CLASSNAME_METADATA);
421 RETURN_NULL_IF_NULL(cls);
422
423 ani_object object = CreateNewObjectByClass(env, cls);
424 RETURN_NULL_IF_NULL(object);
425
426 ani_string string = nullptr;
427
428 // name: string
429 RETURN_NULL_IF_FALSE(StringToAniStr(env, metadata.name, string));
430 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
431
432 // value: string
433 RETURN_NULL_IF_FALSE(StringToAniStr(env, metadata.value, string));
434 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VALUE, string));
435
436 // resource: string
437 RETURN_NULL_IF_FALSE(StringToAniStr(env, metadata.resource, string));
438 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_RESOURCE, string));
439
440 // valueId?: number
441 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_VALUEID, metadata.valueId));
442
443 return object;
444 }
445
ConvertMultiAppMode(ani_env * env,const MultiAppModeData & multiAppMode)446 ani_object CommonFunAni::ConvertMultiAppMode(ani_env* env, const MultiAppModeData& multiAppMode)
447 {
448 RETURN_NULL_IF_NULL(env);
449
450 ani_class cls = CreateClassByName(env, CLASSNAME_MULTIAPPMODE);
451 RETURN_NULL_IF_NULL(cls);
452
453 ani_object object = CreateNewObjectByClass(env, cls);
454 RETURN_NULL_IF_NULL(object);
455
456 // maxCount: number
457 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAXCOUNT, multiAppMode.maxCount));
458
459 // multiAppModeType: bundleManager.MultiAppModeType
460 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MULTIAPPMODETYPE,
461 EnumUtils::EnumNativeToETS_BundleManager_MultiAppModeType(
462 env, static_cast<int32_t>(multiAppMode.multiAppModeType))));
463
464 return object;
465 }
466
ConvertModuleMetaInfosItem(ani_env * env,const std::pair<std::string,std::vector<Metadata>> & item)467 ani_object CommonFunAni::ConvertModuleMetaInfosItem(
468 ani_env* env, const std::pair<std::string, std::vector<Metadata>>& item)
469 {
470 RETURN_NULL_IF_NULL(env);
471
472 ani_class cls = CreateClassByName(env, CLASSNAME_MODULEMETADATA);
473 RETURN_NULL_IF_NULL(cls);
474
475 ani_object object = CreateNewObjectByClass(env, cls);
476 RETURN_NULL_IF_NULL(object);
477
478 ani_string string = nullptr;
479
480 // moduleName: string
481 RETURN_NULL_IF_FALSE(StringToAniStr(env, item.first, string));
482 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
483
484 // metadata: Array<Metadata>
485 ani_object aMetadataObject = ConvertAniArray(env, item.second, ConvertMetadata);
486 RETURN_NULL_IF_NULL(aMetadataObject);
487 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_METADATA, aMetadataObject));
488
489 return object;
490 }
491
ConvertApplicationInfo(ani_env * env,const ApplicationInfo & appInfo)492 ani_object CommonFunAni::ConvertApplicationInfo(ani_env* env, const ApplicationInfo& appInfo)
493 {
494 RETURN_NULL_IF_NULL(env);
495
496 ani_class cls = CreateClassByName(env, CLASSNAME_APPLICATIONINFO);
497 RETURN_NULL_IF_NULL(cls);
498
499 ani_object object = CreateNewObjectByClass(env, cls);
500 RETURN_NULL_IF_NULL(object);
501
502 ani_string string = nullptr;
503
504 // name: string
505 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.name, string));
506 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
507
508 // description: string
509 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.description, string));
510 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTION, string));
511
512 // descriptionId: number
513 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTIONID, appInfo.descriptionId));
514
515 // enabled: boolean
516 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ENABLED, BoolToAniBoolean(appInfo.enabled)));
517
518 // label: string
519 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.label, string));
520 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABEL, string));
521
522 // labelId: number
523 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABELID, appInfo.labelId));
524
525 // icon: string
526 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.iconPath, string));
527 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICON, string));
528
529 // iconId: number
530 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICONID, appInfo.iconId));
531
532 // process: string
533 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.process, string));
534 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PROCESS, string));
535
536 // permissions: Array<string>
537 ani_ref aPermissions = ConvertAniArrayString(env, appInfo.permissions);
538 RETURN_NULL_IF_NULL(aPermissions);
539 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PERMISSIONS, aPermissions));
540
541 // codePath: string
542 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.codePath, string));
543 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_CODEPATH, string));
544
545 // metadataArray: Array<ModuleMetadata>
546 ani_object aMetadataArrayObject = ConvertAniArray(env, appInfo.metadata, ConvertModuleMetaInfosItem);
547 RETURN_NULL_IF_NULL(aMetadataArrayObject);
548 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_METADATAARRAY, aMetadataArrayObject));
549
550 // removable: boolean
551 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_REMOVABLE, BoolToAniBoolean(appInfo.removable)));
552
553 // accessTokenId: number
554 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ACCESSTOKENID, appInfo.accessTokenId));
555
556 // uid: number
557 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_UID, appInfo.uid));
558
559 // iconResource: Resource
560 ani_object aIconResource = ConvertResource(env, appInfo.iconResource);
561 RETURN_NULL_IF_NULL(aIconResource);
562 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICONRESOURCE, aIconResource));
563
564 // labelResource: Resource
565 ani_object aLabelResource = ConvertResource(env, appInfo.labelResource);
566 RETURN_NULL_IF_NULL(aLabelResource);
567 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABELRESOURCE, aLabelResource));
568
569 // descriptionResource: Resource
570 ani_object aDescriptionResource = ConvertResource(env, appInfo.descriptionResource);
571 RETURN_NULL_IF_NULL(aDescriptionResource);
572 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTIONRESOURCE, aDescriptionResource));
573
574 // appDistributionType: string
575 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.appDistributionType, string));
576 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPDISTRIBUTIONTYPE, string));
577
578 // appProvisionType: string
579 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.appProvisionType, string));
580 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPPROVISIONTYPE, string));
581
582 // systemApp: boolean
583 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SYSTEMAPP, BoolToAniBoolean(appInfo.isSystemApp)));
584
585 // bundleType: bundleManager.BundleType
586 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLETYPE,
587 EnumUtils::EnumNativeToETS_BundleManager_BundleType(env, static_cast<int32_t>(appInfo.bundleType))));
588
589 // debug: boolean
590 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEBUG, BoolToAniBoolean(appInfo.debug)));
591
592 // dataUnclearable: boolean
593 RETURN_NULL_IF_FALSE(
594 CallSetter(env, cls, object, PROPERTYNAME_DATAUNCLEARABLE, BoolToAniBoolean(!appInfo.userDataClearable)));
595
596 // nativeLibraryPath: string
597 std::string externalNativeLibraryPath = "";
598 if (!appInfo.nativeLibraryPath.empty()) {
599 externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + appInfo.nativeLibraryPath;
600 }
601 RETURN_NULL_IF_FALSE(StringToAniStr(env, externalNativeLibraryPath, string));
602 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NATIVELIBRARYPATH, string));
603
604 // multiAppMode: MultiAppMode
605 ani_object aniMultiAppModeObj = ConvertMultiAppMode(env, appInfo.multiAppMode);
606 RETURN_NULL_IF_NULL(aniMultiAppModeObj);
607 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MULTIAPPMODE, aniMultiAppModeObj));
608
609 // appIndex: number
610 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, appInfo.appIndex));
611
612 // installSource: string
613 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.installSource, string));
614 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_INSTALLSOURCE, string));
615
616 // releaseType: string
617 RETURN_NULL_IF_FALSE(StringToAniStr(env, appInfo.apiReleaseType, string));
618 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_RELEASETYPE, string));
619
620 // cloudFileSyncEnabled: boolean
621 RETURN_NULL_IF_FALSE(CallSetter(
622 env, cls, object, PROPERTYNAME_CLOUDFILESYNCENABLED, BoolToAniBoolean(appInfo.cloudFileSyncEnabled)));
623
624 // cloudStructuredDataSyncEnabled?: boolean
625 RETURN_NULL_IF_FALSE(CallSetterOptional(
626 env, cls, object, PROPERTYNAME_CLOUDSTRUCTUREDDATASYNCENABLED,
627 BoolToAniBoolean(appInfo.cloudStructuredDataSyncEnabled)));
628
629 // flags?: number
630 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_FLAGS, appInfo.applicationFlags));
631
632 return object;
633 }
634
ConvertAbilityInfo(ani_env * env,const AbilityInfo & abilityInfo)635 ani_object CommonFunAni::ConvertAbilityInfo(ani_env* env, const AbilityInfo& abilityInfo)
636 {
637 RETURN_NULL_IF_NULL(env);
638
639 ani_class cls = CreateClassByName(env, CLASSNAME_ABILITYINFO);
640 RETURN_NULL_IF_NULL(cls);
641
642 ani_object object = CreateNewObjectByClass(env, cls);
643 RETURN_NULL_IF_NULL(object);
644
645 ani_string string = nullptr;
646
647 // bundleName: string
648 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.bundleName, string));
649 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
650
651 // moduleName: string
652 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.moduleName, string));
653 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
654
655 // name: string
656 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.name, string));
657 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
658
659 // label: string
660 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.label, string));
661 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABEL, string));
662
663 // labelId: number
664 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABELID, abilityInfo.labelId));
665
666 // description: string
667 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.description, string));
668 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTION, string));
669
670 // descriptionId: number
671 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTIONID, abilityInfo.descriptionId));
672
673 // icon: string
674 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.iconPath, string));
675 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICON, string));
676
677 // iconId: number
678 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICONID, abilityInfo.iconId));
679
680 // process: string
681 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityInfo.process, string));
682 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PROCESS, string));
683
684 // exported: boolean
685 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_EXPORTED, BoolToAniBoolean(abilityInfo.visible)));
686
687 // orientation: bundleManager.DisplayOrientation
688 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ORIENTATION,
689 EnumUtils::EnumNativeToETS_BundleManager_DisplayOrientation(
690 env, static_cast<int32_t>(abilityInfo.orientation))));
691
692 // launchType: bundleManager.LaunchType
693 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LAUNCHTYPE,
694 EnumUtils::EnumNativeToETS_BundleManager_LaunchType(env, static_cast<int32_t>(abilityInfo.launchMode))));
695
696 // permissions: Array<string>
697 ani_ref aPermissions = ConvertAniArrayString(env, abilityInfo.permissions);
698 RETURN_NULL_IF_NULL(aPermissions);
699 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PERMISSIONS, aPermissions));
700
701 // deviceTypes: Array<string>
702 ani_ref aDeviceTypes = ConvertAniArrayString(env, abilityInfo.deviceTypes);
703 RETURN_NULL_IF_NULL(aDeviceTypes);
704 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEVICETYPES, aDeviceTypes));
705
706 // applicationInfo: ApplicationInfo
707 if (!abilityInfo.applicationInfo.name.empty()) {
708 ani_object aObject = ConvertApplicationInfo(env, abilityInfo.applicationInfo);
709 RETURN_NULL_IF_NULL(aObject);
710 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPLICATIONINFO, aObject));
711 } else {
712 RETURN_NULL_IF_FALSE(CallSetterNull(env, cls, object, PROPERTYNAME_APPLICATIONINFO));
713 }
714
715 // metadata: Array<Metadata>
716 ani_object aMetadataObject = ConvertAniArray(env, abilityInfo.metadata, ConvertMetadata);
717 RETURN_NULL_IF_NULL(aMetadataObject);
718 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_METADATA, aMetadataObject));
719
720 // enabled: boolean
721 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ENABLED, BoolToAniBoolean(abilityInfo.enabled)));
722
723 // supportWindowModes: Array<bundleManager.SupportWindowMode>
724 ani_object aSupportWindowModes =
725 ConvertAniArrayEnum(env, abilityInfo.windowModes, EnumUtils::EnumNativeToETS_BundleManager_SupportWindowMode);
726 RETURN_NULL_IF_NULL(aSupportWindowModes);
727 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SUPPORTWINDOWMODES, aSupportWindowModes));
728
729 // windowSize: WindowSize
730 ani_object aniWindowSizeObj = ConvertWindowSize(env, abilityInfo);
731 RETURN_NULL_IF_NULL(aniWindowSizeObj);
732 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_WINDOWSIZE, aniWindowSizeObj));
733
734 // excludeFromDock: boolean
735 RETURN_NULL_IF_FALSE(
736 CallSetter(env, cls, object, PROPERTYNAME_EXCLUDEFROMDOCK, BoolToAniBoolean(abilityInfo.excludeFromDock)));
737
738 // skills: Array<Skill>
739 ani_object aSkillsObject = ConvertAniArray(env, abilityInfo.skills, ConvertAbilitySkill);
740 RETURN_NULL_IF_NULL(aSkillsObject);
741 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SKILLS, aSkillsObject));
742
743 // appIndex: number
744 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, abilityInfo.appIndex));
745
746 // orientationId: number
747 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ORIENTATIONID, abilityInfo.orientationId));
748
749 return object;
750 }
751
ConvertWindowSize(ani_env * env,const AbilityInfo & abilityInfo)752 ani_object CommonFunAni::ConvertWindowSize(ani_env* env, const AbilityInfo& abilityInfo)
753 {
754 RETURN_NULL_IF_NULL(env);
755
756 ani_class cls = CreateClassByName(env, CLASSNAME_WINDOWSIZE);
757 RETURN_NULL_IF_NULL(cls);
758
759 ani_object object = CreateNewObjectByClass(env, cls);
760 RETURN_NULL_IF_NULL(object);
761
762 // maxWindowRatio: number
763 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAXWINDOWRATIO, abilityInfo.maxWindowRatio));
764
765 // minWindowRatio: number
766 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MINWINDOWRATIO, abilityInfo.minWindowRatio));
767
768 // maxWindowWidth: number
769 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAXWINDOWWIDTH, abilityInfo.maxWindowWidth));
770
771 // minWindowWidth: number
772 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MINWINDOWWIDTH, abilityInfo.minWindowWidth));
773
774 // maxWindowHeight: number
775 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAXWINDOWHEIGHT, abilityInfo.maxWindowHeight));
776
777 // minWindowHeight: number
778 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MINWINDOWHEIGHT, abilityInfo.minWindowHeight));
779
780 return object;
781 }
782
ConvertExtensionInfo(ani_env * env,const ExtensionAbilityInfo & extensionInfo)783 ani_object CommonFunAni::ConvertExtensionInfo(ani_env* env, const ExtensionAbilityInfo& extensionInfo)
784 {
785 RETURN_NULL_IF_NULL(env);
786
787 ani_class cls = CreateClassByName(env, CLASSNAME_EXTENSIONABILITYINFO);
788 RETURN_NULL_IF_NULL(cls);
789
790 ani_object object = CreateNewObjectByClass(env, cls);
791 RETURN_NULL_IF_NULL(object);
792
793 ani_string string = nullptr;
794
795 // bundleName: string
796 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionInfo.bundleName, string));
797 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
798
799 // moduleName: string
800 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionInfo.moduleName, string));
801 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
802
803 // name: string
804 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionInfo.name, string));
805 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
806
807 // labelId: number
808 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABELID, extensionInfo.labelId));
809
810 // descriptionId: number
811 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTIONID, extensionInfo.descriptionId));
812
813 // iconId: number
814 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICONID, extensionInfo.iconId));
815
816 // exported: boolean
817 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_EXPORTED, extensionInfo.visible));
818
819 // extensionAbilityType: bundleManager.ExtensionAbilityType
820 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_EXTENSIONABILITYTYPE,
821 EnumUtils::EnumNativeToETS_BundleManager_ExtensionAbilityType(env, static_cast<int32_t>(extensionInfo.type))));
822
823 // extensionAbilityTypeName: string
824 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionInfo.extensionTypeName, string));
825 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_EXTENSIONABILITYTYPENAME, string));
826
827 // permissions: Array<string>
828 ani_ref aPermissions = ConvertAniArrayString(env, extensionInfo.permissions);
829 RETURN_NULL_IF_NULL(aPermissions);
830 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PERMISSIONS, aPermissions));
831
832 // applicationInfo: ApplicationInfo
833 if (!extensionInfo.applicationInfo.name.empty()) {
834 ani_object aObject = ConvertApplicationInfo(env, extensionInfo.applicationInfo);
835 RETURN_NULL_IF_NULL(aObject);
836 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPLICATIONINFO, aObject));
837 } else {
838 RETURN_NULL_IF_FALSE(CallSetterNull(env, cls, object, PROPERTYNAME_APPLICATIONINFO));
839 }
840
841 // metadata: Array<Metadata>
842 ani_object aMetadataObject = ConvertAniArray(env, extensionInfo.metadata, ConvertMetadata);
843 RETURN_NULL_IF_NULL(aMetadataObject);
844 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_METADATA, aMetadataObject));
845
846 // enabled: boolean
847 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ENABLED, extensionInfo.enabled));
848
849 // readPermission: string
850 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionInfo.readPermission, string));
851 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_READPERMISSION, string));
852
853 // writePermission: string
854 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionInfo.writePermission, string));
855 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_WRITEPERMISSION, string));
856
857 // skills: Array<Skill>
858 ani_object aSkillsObject = ConvertAniArray(env, extensionInfo.skills, ConvertExtensionAbilitySkill);
859 RETURN_NULL_IF_NULL(aSkillsObject);
860 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SKILLS, aSkillsObject));
861
862 // appIndex: number
863 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, extensionInfo.appIndex));
864
865 return object;
866 }
867
ConvertResource(ani_env * env,const Resource & resource)868 ani_object CommonFunAni::ConvertResource(ani_env* env, const Resource& resource)
869 {
870 RETURN_NULL_IF_NULL(env);
871
872 ani_class cls = CreateClassByName(env, CLASSNAME_RESOURCE);
873 RETURN_NULL_IF_NULL(cls);
874
875 ani_object object = CreateNewObjectByClass(env, cls);
876 RETURN_NULL_IF_NULL(object);
877
878 ani_string string = nullptr;
879
880 // bundleName: string
881 RETURN_NULL_IF_FALSE(StringToAniStr(env, resource.bundleName, string));
882 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
883
884 // moduleName: string
885 RETURN_NULL_IF_FALSE(StringToAniStr(env, resource.moduleName, string));
886 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
887
888 // id: number
889 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ID, resource.id));
890
891 return object;
892 }
893
ConvertSignatureInfo(ani_env * env,const SignatureInfo & signatureInfo)894 ani_object CommonFunAni::ConvertSignatureInfo(ani_env* env, const SignatureInfo& signatureInfo)
895 {
896 RETURN_NULL_IF_NULL(env);
897
898 ani_class cls = CreateClassByName(env, CLASSNAME_SIGNATUREINFO);
899 RETURN_NULL_IF_NULL(cls);
900
901 ani_object object = CreateNewObjectByClass(env, cls);
902 RETURN_NULL_IF_NULL(object);
903
904 ani_string string = nullptr;
905
906 // appId: string
907 RETURN_NULL_IF_FALSE(StringToAniStr(env, signatureInfo.appId, string));
908 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPID, string));
909
910 // fingerprint: string
911 RETURN_NULL_IF_FALSE(StringToAniStr(env, signatureInfo.fingerprint, string));
912 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_FINGERPRINT, string));
913
914 // appIdentifier: string
915 RETURN_NULL_IF_FALSE(StringToAniStr(env, signatureInfo.appIdentifier, string));
916 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPIDENTIFIER, string));
917
918 // certificate?: string
919 if (StringToAniStr(env, signatureInfo.certificate, string)) {
920 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_CERTIFICATE, string));
921 }
922
923 return object;
924 }
925
ConvertKeyValuePair(ani_env * env,const std::pair<std::string,std::string> & item,const char * className)926 ani_object CommonFunAni::ConvertKeyValuePair(
927 ani_env* env, const std::pair<std::string, std::string>& item, const char* className)
928 {
929 RETURN_NULL_IF_NULL(env);
930
931 ani_class cls = CreateClassByName(env, CLASSNAME_DATAITEM);
932 RETURN_NULL_IF_NULL(cls);
933
934 ani_object object = CreateNewObjectByClass(env, cls);
935 RETURN_NULL_IF_NULL(object);
936
937 ani_string string = nullptr;
938
939 // key: string
940 RETURN_NULL_IF_FALSE(StringToAniStr(env, item.first, string));
941 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_KEY, string));
942
943 // value: string
944 RETURN_NULL_IF_FALSE(StringToAniStr(env, item.second, string));
945 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VALUE, string));
946
947 return object;
948 }
949
ConvertDataItem(ani_env * env,const std::pair<std::string,std::string> & item)950 inline ani_object CommonFunAni::ConvertDataItem(ani_env* env, const std::pair<std::string, std::string>& item)
951 {
952 return ConvertKeyValuePair(env, item, CLASSNAME_DATAITEM);
953 }
954
ConvertRouterItem(ani_env * env,const RouterItem & routerItem)955 ani_object CommonFunAni::ConvertRouterItem(ani_env* env, const RouterItem& routerItem)
956 {
957 RETURN_NULL_IF_NULL(env);
958
959 ani_class cls = CreateClassByName(env, CLASSNAME_ROUTERITEM);
960 RETURN_NULL_IF_NULL(cls);
961
962 ani_object object = CreateNewObjectByClass(env, cls);
963 RETURN_NULL_IF_NULL(object);
964
965 ani_string string = nullptr;
966
967 // name: string
968 RETURN_NULL_IF_FALSE(StringToAniStr(env, routerItem.name, string));
969 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
970
971 // pageSourceFile: string
972 RETURN_NULL_IF_FALSE(StringToAniStr(env, routerItem.pageSourceFile, string));
973 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PAGESOURCEFILE, string));
974
975 // buildFunction: string
976 RETURN_NULL_IF_FALSE(StringToAniStr(env, routerItem.buildFunction, string));
977 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUILDFUNCTION, string));
978
979 // customData: string
980 RETURN_NULL_IF_FALSE(StringToAniStr(env, routerItem.customData, string));
981 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_CUSTOMDATA, string));
982
983 // data: Array<DataItem>
984 ani_object aDataArrayObject = ConvertAniArray(env, routerItem.data, ConvertDataItem);
985 RETURN_NULL_IF_NULL(aDataArrayObject);
986 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DATA, aDataArrayObject));
987
988 return object;
989 }
990
ConvertRequestPermission(ani_env * env,const RequestPermission & requestPermission)991 ani_object CommonFunAni::ConvertRequestPermission(ani_env* env, const RequestPermission& requestPermission)
992 {
993 RETURN_NULL_IF_NULL(env);
994
995 ani_class cls = CreateClassByName(env, CLASSNAME_PERMISSION);
996 RETURN_NULL_IF_NULL(cls);
997
998 ani_object object = CreateNewObjectByClass(env, cls);
999 RETURN_NULL_IF_NULL(object);
1000
1001 ani_string string = nullptr;
1002
1003 // name: string
1004 RETURN_NULL_IF_FALSE(StringToAniStr(env, requestPermission.name, string));
1005 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1006
1007 // moduleName: string
1008 RETURN_NULL_IF_FALSE(StringToAniStr(env, requestPermission.moduleName, string));
1009 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
1010
1011 // reason: string
1012 RETURN_NULL_IF_FALSE(StringToAniStr(env, requestPermission.reason, string));
1013 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_REASON, string));
1014
1015 // reasonId: number
1016 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_REASONID, requestPermission.reasonId));
1017
1018 // usedScene: UsedScene
1019 ani_object aObject = ConvertRequestPermissionUsedScene(env, requestPermission.usedScene);
1020 RETURN_NULL_IF_NULL(aObject);
1021 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_USEDSCENE, aObject));
1022
1023 return object;
1024 }
1025
ConvertRequestPermissionUsedScene(ani_env * env,const RequestPermissionUsedScene & requestPermissionUsedScene)1026 ani_object CommonFunAni::ConvertRequestPermissionUsedScene(
1027 ani_env* env, const RequestPermissionUsedScene& requestPermissionUsedScene)
1028 {
1029 RETURN_NULL_IF_NULL(env);
1030
1031 ani_class cls = CreateClassByName(env, CLASSNAME_USEDSCENE);
1032 RETURN_NULL_IF_NULL(cls);
1033
1034 ani_object object = CreateNewObjectByClass(env, cls);
1035 RETURN_NULL_IF_NULL(object);
1036
1037 ani_string string = nullptr;
1038 // when: string
1039 RETURN_NULL_IF_FALSE(StringToAniStr(env, requestPermissionUsedScene.when, string));
1040 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_WHEN, string));
1041
1042 // abilities: Array<string>
1043 ani_ref aAbilities = ConvertAniArrayString(env, requestPermissionUsedScene.abilities);
1044 RETURN_NULL_IF_NULL(aAbilities);
1045 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ABILITIES, aAbilities));
1046
1047 return object;
1048 }
1049
ConvertPreloadItem(ani_env * env,const PreloadItem & preloadItem)1050 ani_object CommonFunAni::ConvertPreloadItem(ani_env* env, const PreloadItem& preloadItem)
1051 {
1052 RETURN_NULL_IF_NULL(env);
1053
1054 ani_class cls = CreateClassByName(env, CLASSNAME_PRELOADITEM);
1055 RETURN_NULL_IF_NULL(cls);
1056
1057 ani_object object = CreateNewObjectByClass(env, cls);
1058 RETURN_NULL_IF_NULL(object);
1059
1060 ani_string string = nullptr;
1061
1062 // moduleName: string
1063 RETURN_NULL_IF_FALSE(StringToAniStr(env, preloadItem.moduleName, string));
1064 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
1065
1066 return object;
1067 }
1068
ConvertDependency(ani_env * env,const Dependency & dependency)1069 ani_object CommonFunAni::ConvertDependency(ani_env* env, const Dependency& dependency)
1070 {
1071 RETURN_NULL_IF_NULL(env);
1072
1073 ani_class cls = CreateClassByName(env, CLASSNAME_DEPENDENCY);
1074 RETURN_NULL_IF_NULL(cls);
1075
1076 ani_object object = CreateNewObjectByClass(env, cls);
1077 RETURN_NULL_IF_NULL(object);
1078
1079 ani_string string = nullptr;
1080 // moduleName: string
1081 RETURN_NULL_IF_FALSE(StringToAniStr(env, dependency.moduleName, string));
1082 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
1083
1084 // bundleName: string
1085 RETURN_NULL_IF_FALSE(StringToAniStr(env, dependency.bundleName, string));
1086 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1087
1088 // versionCode: number
1089 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VERSIONCODE, dependency.versionCode));
1090
1091 return object;
1092 }
1093
ConvertHapModuleInfo(ani_env * env,const HapModuleInfo & hapModuleInfo)1094 ani_object CommonFunAni::ConvertHapModuleInfo(ani_env* env, const HapModuleInfo& hapModuleInfo)
1095 {
1096 RETURN_NULL_IF_NULL(env);
1097
1098 ani_class cls = CreateClassByName(env, CLASSNAME_HAPMODULEINFO);
1099 RETURN_NULL_IF_NULL(cls);
1100
1101 ani_object object = CreateNewObjectByClass(env, cls);
1102 RETURN_NULL_IF_NULL(object);
1103
1104 ani_string string = nullptr;
1105
1106 // name: string
1107 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.name, string));
1108 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1109
1110 // icon: string
1111 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.iconPath, string));
1112 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICON, string));
1113
1114 // iconId: number
1115 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICONID, hapModuleInfo.iconId));
1116
1117 // label: string
1118 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.label, string));
1119 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABEL, string));
1120
1121 // labelId: number
1122 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABELID, hapModuleInfo.labelId));
1123
1124 // description: string
1125 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.description, string));
1126 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTION, string));
1127
1128 // descriptionId: number
1129 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DESCRIPTIONID, hapModuleInfo.descriptionId));
1130
1131 // mainElementName: string
1132 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.mainElementName, string));
1133 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAINELEMENTNAME, string));
1134
1135 // abilitiesInfo: Array<AbilityInfo>
1136 ani_object aAbilityInfoObject = ConvertAniArray(env, hapModuleInfo.abilityInfos, ConvertAbilityInfo);
1137 RETURN_NULL_IF_NULL(aAbilityInfoObject);
1138 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ABILITIESINFO, aAbilityInfoObject));
1139
1140 // extensionAbilitiesInfo: Array<ExtensionAbilityInfo>
1141 ani_object aExtensionAbilityInfoObject = ConvertAniArray(env, hapModuleInfo.extensionInfos, ConvertExtensionInfo);
1142 RETURN_NULL_IF_NULL(aExtensionAbilityInfoObject);
1143 RETURN_NULL_IF_FALSE(
1144 CallSetter(env, cls, object, PROPERTYNAME_EXTENSIONABILITIESINFO, aExtensionAbilityInfoObject));
1145
1146 // metadata: Array<Metadata>
1147 ani_object aMetadataObject = ConvertAniArray(env, hapModuleInfo.metadata, ConvertMetadata);
1148 RETURN_NULL_IF_NULL(aMetadataObject);
1149 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_METADATA, aMetadataObject));
1150
1151 // deviceTypes: Array<string>
1152 ani_ref aDeviceTypes = ConvertAniArrayString(env, hapModuleInfo.deviceTypes);
1153 RETURN_NULL_IF_NULL(aDeviceTypes);
1154 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEVICETYPES, aDeviceTypes));
1155
1156 // installationFree: boolean
1157 RETURN_NULL_IF_FALSE(
1158 CallSetter(env, cls, object, PROPERTYNAME_INSTALLATIONFREE, BoolToAniBoolean(hapModuleInfo.installationFree)));
1159
1160 // hashValue: string
1161 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.hashValue, string));
1162 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_HASHVALUE, string));
1163
1164 // type: bundleManager.ModuleType
1165 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TYPE,
1166 EnumUtils::EnumNativeToETS_BundleManager_ModuleType(env, static_cast<int32_t>(hapModuleInfo.moduleType))));
1167
1168 // dependencies: Array<Dependency>
1169 ani_object aDependenciesObject = ConvertAniArray(env, hapModuleInfo.dependencies, ConvertDependency);
1170 RETURN_NULL_IF_NULL(aDependenciesObject);
1171 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEPENDENCIES, aDependenciesObject));
1172
1173 // preloads: Array<PreloadItem>
1174 ani_object aPreloadsObject = ConvertAniArray(env, hapModuleInfo.preloads, ConvertPreloadItem);
1175 RETURN_NULL_IF_NULL(aPreloadsObject);
1176 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PRELOADS, aPreloadsObject));
1177
1178 // fileContextMenuConfig: string
1179 if (!hapModuleInfo.fileContextMenu.empty()) {
1180 RETURN_NULL_IF_FALSE(StringToAniStr(env, hapModuleInfo.fileContextMenu, string));
1181 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_FILECONTEXTMENUCONFIG, string));
1182 }
1183
1184 // routerMap: Array<RouterItem>
1185 ani_object aRouterMapObject = ConvertAniArray(env, hapModuleInfo.routerArray, ConvertRouterItem);
1186 RETURN_NULL_IF_NULL(aRouterMapObject);
1187 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ROUTERMAP, aRouterMapObject));
1188
1189 // nativeLibraryPath: string
1190 std::string externalNativeLibraryPath = "";
1191 if (!hapModuleInfo.nativeLibraryPath.empty() && !hapModuleInfo.moduleName.empty()) {
1192 externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + hapModuleInfo.nativeLibraryPath;
1193 }
1194 RETURN_NULL_IF_FALSE(StringToAniStr(env, externalNativeLibraryPath, string));
1195 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NATIVELIBRARYPATH, string));
1196
1197 // codePath: string
1198 std::string codePath = hapModuleInfo.hapPath;
1199 size_t result = hapModuleInfo.hapPath.find(PATH_PREFIX);
1200 if (result != std::string::npos) {
1201 size_t pos = hapModuleInfo.hapPath.find_last_of('/');
1202 codePath = CODE_PATH_PREFIX;
1203 if (pos != std::string::npos && pos != hapModuleInfo.hapPath.size() - 1) {
1204 codePath.append(hapModuleInfo.hapPath.substr(pos + 1));
1205 }
1206 }
1207 RETURN_NULL_IF_FALSE(StringToAniStr(env, codePath, string));
1208 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_CODEPATH, string));
1209
1210 return object;
1211 }
1212
ConvertElementName(ani_env * env,const ElementName & elementName)1213 ani_object CommonFunAni::ConvertElementName(ani_env* env, const ElementName& elementName)
1214 {
1215 RETURN_NULL_IF_NULL(env);
1216
1217 ani_class cls = CreateClassByName(env, CLASSNAME_ELEMENTNAME);
1218 RETURN_NULL_IF_NULL(cls);
1219
1220 ani_object object = CreateNewObjectByClass(env, cls);
1221 RETURN_NULL_IF_NULL(object);
1222
1223 ani_string string = nullptr;
1224
1225 // deviceId?: string
1226 if (StringToAniStr(env, elementName.GetDeviceID(), string)) {
1227 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_DEVICEID, string));
1228 }
1229
1230 // bundleName: string
1231 RETURN_NULL_IF_FALSE(StringToAniStr(env, elementName.GetBundleName(), string));
1232 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1233
1234 // moduleName?: string
1235 if (StringToAniStr(env, elementName.GetModuleName(), string)) {
1236 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_MODULENAME, string));
1237 }
1238
1239 // abilityName: string
1240 RETURN_NULL_IF_FALSE(StringToAniStr(env, elementName.GetAbilityName(), string));
1241 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ABILITYNAME, string));
1242
1243 // uri?: string
1244 if (StringToAniStr(env, elementName.GetURI(), string)) {
1245 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_URI, string));
1246 }
1247
1248 // shortName?: string
1249 if (StringToAniStr(env, "", string)) {
1250 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_SHORTNAME, string));
1251 }
1252
1253 return object;
1254 }
1255
ConvertAbilitySkillUriInner(ani_env * env,const SkillUri & skillUri,bool isExtension)1256 ani_object CommonFunAni::ConvertAbilitySkillUriInner(ani_env* env, const SkillUri& skillUri, bool isExtension)
1257 {
1258 RETURN_NULL_IF_NULL(env);
1259
1260 ani_class cls = CreateClassByName(env, CLASSNAME_SKILLURI);
1261 RETURN_NULL_IF_NULL(cls);
1262
1263 ani_object object = CreateNewObjectByClass(env, cls);
1264 RETURN_NULL_IF_NULL(object);
1265
1266 ani_string string = nullptr;
1267
1268 // scheme: string
1269 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.scheme, string));
1270 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SCHEME, string));
1271
1272 // host: string
1273 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.host, string));
1274 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_HOST, string));
1275
1276 // port: number
1277 int32_t nPort = 0;
1278 if (!skillUri.port.empty()) {
1279 auto [ptr, ec] = std::from_chars(skillUri.port.data(), skillUri.port.data() + skillUri.port.size(), nPort);
1280 if (ec != std::errc() || ptr != skillUri.port.data() + skillUri.port.size()) {
1281 APP_LOGE("skillUri port convert failed");
1282 return nullptr;
1283 }
1284 }
1285 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PORT, nPort));
1286
1287 // path: string
1288 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.path, string));
1289 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PATH, string));
1290
1291 // pathStartWith: string
1292 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.pathStartWith, string));
1293 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PATHSTARTWITH, string));
1294
1295 // pathRegex: string
1296 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.pathRegex, string));
1297 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PATHREGEX, string));
1298
1299 // type: string
1300 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.type, string));
1301 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TYPE, string));
1302
1303 // utd: string
1304 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.utd, string));
1305 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_UTD, string));
1306
1307 // maxFileSupported: number
1308 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAXFILESUPPORTED, skillUri.maxFileSupported));
1309
1310 if (!isExtension) {
1311 // linkFeature: string
1312 RETURN_NULL_IF_FALSE(StringToAniStr(env, skillUri.linkFeature, string));
1313 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LINKFEATURE, string));
1314 }
1315
1316 return object;
1317 }
1318
ConvertAbilitySkillInner(ani_env * env,const Skill & skill,bool isExtension)1319 ani_object CommonFunAni::ConvertAbilitySkillInner(ani_env* env, const Skill& skill, bool isExtension)
1320 {
1321 RETURN_NULL_IF_NULL(env);
1322
1323 ani_class cls = CreateClassByName(env, CLASSNAME_SKILL);
1324 RETURN_NULL_IF_NULL(cls);
1325
1326 ani_object object = CreateNewObjectByClass(env, cls);
1327 RETURN_NULL_IF_NULL(object);
1328
1329 // actions: Array<string>
1330 ani_ref aActions = ConvertAniArrayString(env, skill.actions);
1331 RETURN_NULL_IF_NULL(aActions);
1332 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ACTIONS, aActions));
1333
1334 // entities: Array<string>
1335 ani_ref aEntities = ConvertAniArrayString(env, skill.entities);
1336 RETURN_NULL_IF_NULL(aEntities);
1337 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ENTITIES, aEntities));
1338
1339 // uris: Array<SkillUri>
1340 ani_object aSkillUri =
1341 ConvertAniArray(env, skill.uris, isExtension ? ConvertExtensionAbilitySkillUri : ConvertAbilitySkillUri);
1342 RETURN_NULL_IF_NULL(aSkillUri);
1343 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_URIS, aSkillUri));
1344
1345 if (!isExtension) {
1346 // domainVerify: boolean
1347 RETURN_NULL_IF_FALSE(
1348 CallSetter(env, cls, object, PROPERTYNAME_DOMAINVERIFY, BoolToAniBoolean(skill.domainVerify)));
1349 }
1350
1351 return object;
1352 }
1353
ConvertAppCloneIdentity(ani_env * env,const std::string & bundleName,const int32_t appIndex)1354 ani_object CommonFunAni::ConvertAppCloneIdentity(ani_env* env, const std::string& bundleName, const int32_t appIndex)
1355 {
1356 RETURN_NULL_IF_NULL(env);
1357
1358 ani_class cls = CreateClassByName(env, CLASSNAME_APPCLONEIDENTITY);
1359 RETURN_NULL_IF_NULL(cls);
1360
1361 ani_object object = CreateNewObjectByClass(env, cls);
1362 RETURN_NULL_IF_NULL(object);
1363
1364 ani_string string = nullptr;
1365
1366 // name: string
1367 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleName, string));
1368 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1369
1370 // appIndex: number
1371 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, appIndex));
1372
1373 return object;
1374 }
1375
ConvertBundleResourceInfo(ani_env * env,const BundleResourceInfo & bundleResInfo)1376 ani_object CommonFunAni::ConvertBundleResourceInfo(ani_env* env, const BundleResourceInfo& bundleResInfo)
1377 {
1378 RETURN_NULL_IF_NULL(env);
1379
1380 ani_class cls = CreateClassByName(env, CLASSNAME_BUNDLERESINFO);
1381 RETURN_NULL_IF_NULL(cls);
1382
1383 ani_object object = CreateNewObjectByClass(env, cls);
1384 RETURN_NULL_IF_NULL(object);
1385
1386 ani_string string = nullptr;
1387
1388 // bundleName: string
1389 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleResInfo.bundleName, string));
1390 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1391
1392 // icon: string
1393 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleResInfo.icon, string));
1394 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICON, string));
1395
1396 // label: string
1397 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleResInfo.label, string));
1398 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABEL, string));
1399
1400 // drawableDecriptor: drawableDecriptor
1401
1402 // appIndex: number
1403 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, bundleResInfo.appIndex));
1404
1405 return object;
1406 }
1407
ConvertLauncherAbilityResourceInfo(ani_env * env,const LauncherAbilityResourceInfo & launcherAbilityResourceInfo)1408 ani_object CommonFunAni::ConvertLauncherAbilityResourceInfo(
1409 ani_env* env, const LauncherAbilityResourceInfo& launcherAbilityResourceInfo)
1410 {
1411 RETURN_NULL_IF_NULL(env);
1412
1413 ani_class cls = CreateClassByName(env, CLASSNAME_LAUNCHER_ABILITY_RESOURCE_INFO_INNER);
1414 RETURN_NULL_IF_NULL(cls);
1415
1416 ani_object object = CreateNewObjectByClass(env, cls);
1417 RETURN_NULL_IF_NULL(object);
1418
1419 ani_string string = nullptr;
1420
1421 // bundleName: string
1422 RETURN_NULL_IF_FALSE(StringToAniStr(env, launcherAbilityResourceInfo.bundleName, string));
1423 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1424
1425 // moduleName: string
1426 RETURN_NULL_IF_FALSE(StringToAniStr(env, launcherAbilityResourceInfo.moduleName, string));
1427 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
1428
1429 // abilityName: string
1430 RETURN_NULL_IF_FALSE(StringToAniStr(env, launcherAbilityResourceInfo.abilityName, string));
1431 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ABILITYNAME, string));
1432
1433 // icon: string
1434 RETURN_NULL_IF_FALSE(StringToAniStr(env, launcherAbilityResourceInfo.icon, string));
1435 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICON, string));
1436
1437 // label: string
1438 RETURN_NULL_IF_FALSE(StringToAniStr(env, launcherAbilityResourceInfo.label, string));
1439 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABEL, string));
1440
1441 // drawableDescriptor: DrawableDescriptor;
1442
1443 // appIndex: number
1444 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, launcherAbilityResourceInfo.appIndex));
1445
1446 return object;
1447 }
1448
ConvertShortcutInfo(ani_env * env,const ShortcutInfo & shortcutInfo)1449 ani_object CommonFunAni::ConvertShortcutInfo(ani_env* env, const ShortcutInfo& shortcutInfo)
1450 {
1451 RETURN_NULL_IF_NULL(env);
1452
1453 ani_class cls = CreateClassByName(env, CLASSNAME_SHORTCUTINFO);
1454 RETURN_NULL_IF_NULL(cls);
1455
1456 ani_object object = CreateNewObjectByClass(env, cls);
1457 RETURN_NULL_IF_NULL(object);
1458
1459 ani_string string = nullptr;
1460
1461 // id: string
1462 RETURN_NULL_IF_FALSE(StringToAniStr(env, shortcutInfo.id, string));
1463 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ID, string));
1464
1465 // bundleName: string
1466 RETURN_NULL_IF_FALSE(StringToAniStr(env, shortcutInfo.bundleName, string));
1467 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1468
1469 // moduleName?: string
1470 if (StringToAniStr(env, shortcutInfo.moduleName, string)) {
1471 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_MODULENAME, string));
1472 }
1473
1474 // hostAbility?: string
1475 if (StringToAniStr(env, shortcutInfo.hostAbility, string)) {
1476 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_HOSTABILITY, string));
1477 }
1478
1479 // icon?: string
1480 if (StringToAniStr(env, shortcutInfo.icon, string)) {
1481 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_ICON, string));
1482 }
1483
1484 // iconId?: number
1485 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_ICONID, shortcutInfo.iconId));
1486
1487 // label?: string
1488 if (StringToAniStr(env, shortcutInfo.label, string)) {
1489 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_LABEL, string));
1490 }
1491
1492 // labelId?: number
1493 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_LABELID, shortcutInfo.labelId));
1494
1495 // wants?: Array<ShortcutWant>
1496 ani_object aShortcutWantObject = ConvertAniArray(env, shortcutInfo.intents, ConvertShortcutIntent);
1497 RETURN_NULL_IF_NULL(aShortcutWantObject);
1498 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_WANTS, aShortcutWantObject));
1499
1500 // appIndex: number
1501 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, shortcutInfo.appIndex));
1502
1503 // sourceType: number
1504 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SOURCETYPE, shortcutInfo.sourceType));
1505
1506 // visible?: boolean
1507 RETURN_NULL_IF_FALSE(CallSetterOptional(
1508 env, cls, object, PROPERTYNAME_VISIBLE, BoolToAniBoolean(shortcutInfo.visible)));
1509
1510 return object;
1511 }
1512
ConvertShortcutIntent(ani_env * env,const ShortcutIntent & shortcutIntent)1513 ani_object CommonFunAni::ConvertShortcutIntent(ani_env* env, const ShortcutIntent& shortcutIntent)
1514 {
1515 RETURN_NULL_IF_NULL(env);
1516
1517 ani_class cls = CreateClassByName(env, CLASSNAME_SHORTCUTWANT);
1518 RETURN_NULL_IF_NULL(cls);
1519
1520 ani_object object = CreateNewObjectByClass(env, cls);
1521 RETURN_NULL_IF_NULL(object);
1522
1523 ani_string string = nullptr;
1524
1525 // targetBundle: string
1526 RETURN_NULL_IF_FALSE(StringToAniStr(env, shortcutIntent.targetBundle, string));
1527 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TARGETBUNDLE, string));
1528
1529 // targetModule?: string
1530 if (StringToAniStr(env, shortcutIntent.targetModule, string)) {
1531 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_TARGETMODULE, string));
1532 }
1533
1534 // targetAbility: string
1535 RETURN_NULL_IF_FALSE(StringToAniStr(env, shortcutIntent.targetClass, string));
1536 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TARGETABILITY, string));
1537
1538 // parameters?: Array<ParameterItem>
1539 ani_object aParameters = ConvertAniArray(env, shortcutIntent.parameters, ConvertShortcutIntentParameter);
1540 RETURN_NULL_IF_NULL(aParameters);
1541 RETURN_NULL_IF_FALSE(CallSetterOptional(env, cls, object, PROPERTYNAME_PARAMETERS, aParameters));
1542
1543 return object;
1544 }
1545
ConvertShortcutIntentParameter(ani_env * env,const std::pair<std::string,std::string> & item)1546 inline ani_object CommonFunAni::ConvertShortcutIntentParameter(
1547 ani_env* env, const std::pair<std::string, std::string>& item)
1548 {
1549 return ConvertKeyValuePair(env, item, CLASSNAME_SHORTCUT_PARAMETERITEM);
1550 }
1551
ConvertLauncherAbilityInfo(ani_env * env,const LauncherAbilityInfo & launcherAbility)1552 ani_object CommonFunAni::ConvertLauncherAbilityInfo(ani_env* env, const LauncherAbilityInfo& launcherAbility)
1553 {
1554 RETURN_NULL_IF_NULL(env);
1555
1556 ani_class cls = CreateClassByName(env, CLASSNAME_LAUNCHER_ABILITY_INFO_INNER);
1557 RETURN_NULL_IF_NULL(cls);
1558
1559 ani_object object = CreateNewObjectByClass(env, cls);
1560 RETURN_NULL_IF_NULL(object);
1561
1562 // applicationInfo: ApplicationInfo
1563 ani_object aObject = ConvertApplicationInfo(env, launcherAbility.applicationInfo);
1564 RETURN_NULL_IF_NULL(aObject);
1565 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPLICATIONINFO, aObject));
1566
1567 // elementName: ElementName
1568 ani_object aElementNameObject = ConvertElementName(env, launcherAbility.elementName);
1569 RETURN_NULL_IF_NULL(aElementNameObject);
1570 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ELEMENTNAME, aElementNameObject));
1571
1572 // labelId: number
1573 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABELID, launcherAbility.labelId));
1574
1575 // iconId: number
1576 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ICONID, launcherAbility.iconId));
1577
1578 // userId: number
1579 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_USERID, launcherAbility.userId));
1580
1581 // installTime: number
1582 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_INSTALLTIME, launcherAbility.installTime));
1583
1584 return object;
1585 }
1586
ConvertOverlayModuleInfo(ani_env * env,const OverlayModuleInfo & overlayModuleInfo)1587 ani_object CommonFunAni::ConvertOverlayModuleInfo(ani_env* env, const OverlayModuleInfo& overlayModuleInfo)
1588 {
1589 RETURN_NULL_IF_NULL(env);
1590
1591 ani_class cls = CreateClassByName(env, CLASSNAME_OVERLAY_MOUDLE_INFO_INNER);
1592 RETURN_NULL_IF_NULL(cls);
1593
1594 ani_object object = CreateNewObjectByClass(env, cls);
1595 RETURN_NULL_IF_NULL(object);
1596
1597 ani_string string = nullptr;
1598
1599 // bundleName: string
1600 RETURN_NULL_IF_FALSE(StringToAniStr(env, overlayModuleInfo.bundleName, string));
1601 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1602
1603 // moduleName: string
1604 RETURN_NULL_IF_FALSE(StringToAniStr(env, overlayModuleInfo.moduleName, string));
1605 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
1606
1607 // targetModuleName: string
1608 RETURN_NULL_IF_FALSE(StringToAniStr(env, overlayModuleInfo.targetModuleName, string));
1609 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TARGETMOUDLENAME, string));
1610
1611 // priority: number
1612 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PRIORITY, overlayModuleInfo.priority));
1613
1614 // state: number
1615 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_STATE, overlayModuleInfo.state));
1616
1617 return object;
1618 }
1619
CreateBundleChangedInfo(ani_env * env,const std::string & bundleName,int32_t userId,int32_t appIndex)1620 ani_object CommonFunAni::CreateBundleChangedInfo(
1621 ani_env* env, const std::string& bundleName, int32_t userId, int32_t appIndex)
1622 {
1623 RETURN_NULL_IF_NULL(env);
1624
1625 ani_class cls = CreateClassByName(env, CLASSNAME_BUNDLE_CHANGED_INFO_INNER);
1626 RETURN_NULL_IF_NULL(cls);
1627
1628 ani_object object = CreateNewObjectByClass(env, cls);
1629 RETURN_NULL_IF_NULL(object);
1630
1631 ani_string string = nullptr;
1632
1633 // bundleName: string
1634 RETURN_NULL_IF_FALSE(StringToAniStr(env, bundleName, string));
1635 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1636
1637 // userId: number
1638 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_USERID, userId));
1639
1640 // appIndex: number
1641 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APPINDEX, appIndex));
1642
1643 return object;
1644 }
1645
ConvertVersion(ani_env * env,const Version & version)1646 ani_object CommonFunAni::ConvertVersion(ani_env* env, const Version& version)
1647 {
1648 RETURN_NULL_IF_NULL(env);
1649
1650 ani_class cls = CreateClassByName(env, CLASSNAME_VERSION_INNER);
1651 RETURN_NULL_IF_NULL(cls);
1652
1653 ani_object object = CreateNewObjectByClass(env, cls);
1654 RETURN_NULL_IF_NULL(object);
1655
1656 ani_string string = nullptr;
1657
1658 // minCompatibleVersionCode: number
1659 RETURN_NULL_IF_FALSE(
1660 CallSetter(env, cls, object, PROPERTYNAME_MINCOMPATIBLEVERSIONCODE, version.minCompatibleVersionCode));
1661
1662 // name: string
1663 RETURN_NULL_IF_FALSE(StringToAniStr(env, version.name, string));
1664 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1665
1666 // code: number
1667 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_CODE, version.code));
1668
1669 return object;
1670 }
1671
ConvertPackageApp(ani_env * env,const PackageApp & packageApp)1672 ani_object CommonFunAni::ConvertPackageApp(ani_env* env, const PackageApp& packageApp)
1673 {
1674 RETURN_NULL_IF_NULL(env);
1675
1676 ani_class cls = CreateClassByName(env, CLASSNAME_BUNDLE_CONFIG_INFO_INNER);
1677 RETURN_NULL_IF_NULL(cls);
1678
1679 ani_object object = CreateNewObjectByClass(env, cls);
1680 RETURN_NULL_IF_NULL(object);
1681
1682 ani_string string = nullptr;
1683
1684 // bundleName: string
1685 RETURN_NULL_IF_FALSE(StringToAniStr(env, packageApp.bundleName, string));
1686 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
1687
1688 // version: Version
1689 ani_object aObject = ConvertVersion(env, packageApp.version);
1690 RETURN_NULL_IF_NULL(aObject);
1691 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VERSION, aObject));
1692
1693 return object;
1694 }
1695
ConvertAbilityFormInfo(ani_env * env,const AbilityFormInfo & abilityFormInfo)1696 ani_object CommonFunAni::ConvertAbilityFormInfo(ani_env* env, const AbilityFormInfo& abilityFormInfo)
1697 {
1698 RETURN_NULL_IF_NULL(env);
1699
1700 ani_class cls = CreateClassByName(env, CLASSNAME_ABILITY_FORM_INFO_INNER);
1701 RETURN_NULL_IF_NULL(cls);
1702
1703 ani_object object = CreateNewObjectByClass(env, cls);
1704 RETURN_NULL_IF_NULL(object);
1705
1706 ani_string string = nullptr;
1707
1708 // name: string
1709 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityFormInfo.name, string));
1710 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1711
1712 // type: string
1713 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityFormInfo.type, string));
1714 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TYPE, string));
1715
1716 // updateEnabled: boolean
1717 RETURN_NULL_IF_FALSE(
1718 CallSetter(env, cls, object, PROPERTYNAME_UPDATEENABLED, BoolToAniBoolean(abilityFormInfo.updateEnabled)));
1719
1720 // scheduledUpdateTime: string
1721 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityFormInfo.scheduledUpdateTime, string));
1722 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SCHEDULEDUPDATETIME, string));
1723
1724 // updateDuration: number
1725 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_UPDATEDURATION, abilityFormInfo.updateDuration));
1726
1727 // supportDimensions: Array<string>
1728 ani_ref aSupportDimensions = ConvertAniArrayString(env, abilityFormInfo.supportDimensions);
1729 RETURN_NULL_IF_NULL(aSupportDimensions);
1730 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SUPPORTDIMENSIONS, aSupportDimensions));
1731
1732 // defaultDimension: string
1733 RETURN_NULL_IF_FALSE(StringToAniStr(env, abilityFormInfo.defaultDimension, string));
1734 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEFAULTDIMENSION, string));
1735
1736 return object;
1737 }
1738
ConvertModuleAbilityInfo(ani_env * env,const ModuleAbilityInfo & moduleAbilityInfo)1739 ani_object CommonFunAni::ConvertModuleAbilityInfo(ani_env* env, const ModuleAbilityInfo& moduleAbilityInfo)
1740 {
1741 RETURN_NULL_IF_NULL(env);
1742
1743 ani_class cls = CreateClassByName(env, CLASSNAME_MODULE_ABILITY_INFO_INNER);
1744 RETURN_NULL_IF_NULL(cls);
1745
1746 ani_object object = CreateNewObjectByClass(env, cls);
1747 RETURN_NULL_IF_NULL(object);
1748
1749 ani_string string = nullptr;
1750
1751 // name: string
1752 RETURN_NULL_IF_FALSE(StringToAniStr(env, moduleAbilityInfo.name, string));
1753 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1754
1755 // label: string
1756 RETURN_NULL_IF_FALSE(StringToAniStr(env, moduleAbilityInfo.label, string));
1757 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_LABEL, string));
1758
1759 // exported: boolean
1760 RETURN_NULL_IF_FALSE(
1761 CallSetter(env, cls, object, PROPERTYNAME_EXPORTED, BoolToAniBoolean(moduleAbilityInfo.visible)));
1762
1763 // forms: Array<AbilityFormInfo>
1764 ani_object aAbilityFormInfoObject = ConvertAniArray(env, moduleAbilityInfo.forms, ConvertAbilityFormInfo);
1765 RETURN_NULL_IF_NULL(aAbilityFormInfoObject);
1766 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_FORMS, aAbilityFormInfoObject));
1767
1768 return object;
1769 }
1770
ConvertModuleDistro(ani_env * env,const ModuleDistro & moduleDistro)1771 ani_object CommonFunAni::ConvertModuleDistro(ani_env* env, const ModuleDistro& moduleDistro)
1772 {
1773 RETURN_NULL_IF_NULL(env);
1774
1775 ani_class cls = CreateClassByName(env, CLASSNAME_MODULE_DISTRO_INFO_INNER);
1776 RETURN_NULL_IF_NULL(cls);
1777
1778 ani_object object = CreateNewObjectByClass(env, cls);
1779 RETURN_NULL_IF_NULL(object);
1780
1781 ani_string string = nullptr;
1782
1783 // deliveryWithInstall: boolean
1784 RETURN_NULL_IF_FALSE(CallSetter(
1785 env, cls, object, PROPERTYNAME_DELIVERYWITHINSTALL, BoolToAniBoolean(moduleDistro.deliveryWithInstall)));
1786
1787 // installationFree: boolean
1788 RETURN_NULL_IF_FALSE(
1789 CallSetter(env, cls, object, PROPERTYNAME_INSTALLATIONFREE, BoolToAniBoolean(moduleDistro.installationFree)));
1790
1791 // moduleName: string
1792 RETURN_NULL_IF_FALSE(StringToAniStr(env, moduleDistro.moduleName, string));
1793 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULENAME, string));
1794
1795 // moduleType: string
1796 RETURN_NULL_IF_FALSE(StringToAniStr(env, moduleDistro.moduleType, string));
1797 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULETYPE, string));
1798
1799 return object;
1800 }
1801
ConvertApiVersion(ani_env * env,const ApiVersion & apiVersion)1802 ani_object CommonFunAni::ConvertApiVersion(ani_env* env, const ApiVersion& apiVersion)
1803 {
1804 RETURN_NULL_IF_NULL(env);
1805
1806 ani_class cls = CreateClassByName(env, CLASSNAME_API_VERSION_INNER);
1807 RETURN_NULL_IF_NULL(cls);
1808
1809 ani_object object = CreateNewObjectByClass(env, cls);
1810 RETURN_NULL_IF_NULL(object);
1811
1812 ani_string string = nullptr;
1813
1814 // releaseType: string
1815 RETURN_NULL_IF_FALSE(StringToAniStr(env, apiVersion.releaseType, string));
1816 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_RELEASETYPE, string));
1817
1818 // compatible: number
1819 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_COMPATIBLE, apiVersion.compatible));
1820
1821 // target: number
1822 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_TARGET, apiVersion.target));
1823
1824 return object;
1825 }
1826
ConvertExtensionAbilities(ani_env * env,const ExtensionAbilities & extensionAbilities)1827 ani_object CommonFunAni::ConvertExtensionAbilities(ani_env* env, const ExtensionAbilities& extensionAbilities)
1828 {
1829 RETURN_NULL_IF_NULL(env);
1830
1831 ani_class cls = CreateClassByName(env, CLASSNAME_EXTENSION_ABILITY_INNER);
1832 RETURN_NULL_IF_NULL(cls);
1833
1834 ani_object object = CreateNewObjectByClass(env, cls);
1835 RETURN_NULL_IF_NULL(object);
1836
1837 ani_string string = nullptr;
1838
1839 // name: string
1840 RETURN_NULL_IF_FALSE(StringToAniStr(env, extensionAbilities.name, string));
1841 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1842
1843 // forms: Array<AbilityFormInfo>
1844 ani_object aAbilityFormInfoObject = ConvertAniArray(env, extensionAbilities.forms, ConvertAbilityFormInfo);
1845 RETURN_NULL_IF_NULL(aAbilityFormInfoObject);
1846 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_FORMS, aAbilityFormInfoObject));
1847
1848 return object;
1849 }
1850
ConvertPackageModule(ani_env * env,const PackageModule & packageModule)1851 ani_object CommonFunAni::ConvertPackageModule(ani_env* env, const PackageModule& packageModule)
1852 {
1853 RETURN_NULL_IF_NULL(env);
1854
1855 ani_class cls = CreateClassByName(env, CLASSNAME_MODULE_CONFIG_INFO_INNER);
1856 RETURN_NULL_IF_NULL(cls);
1857
1858 ani_object object = CreateNewObjectByClass(env, cls);
1859 RETURN_NULL_IF_NULL(object);
1860
1861 ani_string string = nullptr;
1862
1863 // mainAbility: string
1864 RETURN_NULL_IF_FALSE(StringToAniStr(env, packageModule.mainAbility, string));
1865 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MAINABILITY, string));
1866
1867 // apiVersion: ApiVersion
1868 ani_object aApiVersionObject = ConvertApiVersion(env, packageModule.apiVersion);
1869 RETURN_NULL_IF_NULL(aApiVersionObject);
1870 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APIVERSION, aApiVersionObject));
1871
1872 // deviceTypes: Array<string>
1873 ani_ref aDeviceTypes = ConvertAniArrayString(env, packageModule.deviceType);
1874 RETURN_NULL_IF_NULL(aDeviceTypes);
1875 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEVICETYPES, aDeviceTypes));
1876
1877 // distro: ModuleDistroInfo
1878 ani_object aModuleDistroInfoObject = ConvertModuleDistro(env, packageModule.distro);
1879 RETURN_NULL_IF_NULL(aModuleDistroInfoObject);
1880 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DISTRO, aModuleDistroInfoObject));
1881
1882 // abilities: Array<ModuleAbilityInfo>
1883 ani_object aModuleAbilityInfoObject = ConvertAniArray(env, packageModule.abilities, ConvertModuleAbilityInfo);
1884 RETURN_NULL_IF_NULL(aModuleAbilityInfoObject);
1885 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_ABILITIES, aModuleAbilityInfoObject));
1886
1887 // extensionAbilities: Array<ExtensionAbility>
1888 ani_object aExtensionAbilityObject =
1889 ConvertAniArray(env, packageModule.extensionAbilities, ConvertExtensionAbilities);
1890 RETURN_NULL_IF_NULL(aExtensionAbilityObject);
1891 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_EXTENSIONABILITIES, aExtensionAbilityObject));
1892
1893 return object;
1894 }
1895
ConvertSummary(ani_env * env,const Summary & summary,bool withApp)1896 ani_object CommonFunAni::ConvertSummary(ani_env* env, const Summary& summary, bool withApp)
1897 {
1898 RETURN_NULL_IF_NULL(env);
1899
1900 ani_class cls = CreateClassByName(env, CLASSNAME_PACKAGE_SUMMARY_INNER);
1901 RETURN_NULL_IF_NULL(cls);
1902
1903 ani_object object = CreateNewObjectByClass(env, cls);
1904 RETURN_NULL_IF_NULL(object);
1905
1906 if (withApp) {
1907 // app: BundleConfigInfo
1908 ani_object aBundleConfigInfoObject = ConvertPackageApp(env, summary.app);
1909 RETURN_NULL_IF_NULL(aBundleConfigInfoObject);
1910 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_APP, aBundleConfigInfoObject));
1911 }
1912
1913 // modules: Array<ModuleConfigInfo>
1914 ani_object aModuleConfigInfoObject = ConvertAniArray(env, summary.modules, ConvertPackageModule);
1915 RETURN_NULL_IF_NULL(aModuleConfigInfoObject);
1916 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULES, aModuleConfigInfoObject));
1917
1918 return object;
1919 }
1920
ConvertPackages(ani_env * env,const Packages & packages)1921 ani_object CommonFunAni::ConvertPackages(ani_env* env, const Packages& packages)
1922 {
1923 RETURN_NULL_IF_NULL(env);
1924
1925 ani_class cls = CreateClassByName(env, CLASSNAME_PACKAGE_CONFIG_INNER);
1926 RETURN_NULL_IF_NULL(cls);
1927
1928 ani_object object = CreateNewObjectByClass(env, cls);
1929 RETURN_NULL_IF_NULL(object);
1930
1931 ani_string string = nullptr;
1932
1933 // deviceTypes: Array<string>
1934 ani_ref aDeviceTypes = ConvertAniArrayString(env, packages.deviceType);
1935 RETURN_NULL_IF_NULL(aDeviceTypes);
1936 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DEVICETYPES, aDeviceTypes));
1937
1938 // name: string
1939 RETURN_NULL_IF_FALSE(StringToAniStr(env, packages.name, string));
1940 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_NAME, string));
1941
1942 // moduleType: string
1943 RETURN_NULL_IF_FALSE(StringToAniStr(env, packages.moduleType, string));
1944 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_MODULETYPE, string));
1945
1946 // deliveryWithInstall: boolean
1947 RETURN_NULL_IF_FALSE(
1948 CallSetter(env, cls, object, PROPERTYNAME_DELIVERYWITHINSTALL, BoolToAniBoolean(packages.deliveryWithInstall)));
1949
1950 return object;
1951 }
1952
ConvertBundlePackInfo(ani_env * env,const BundlePackInfo & bundlePackInfo,const uint32_t flag)1953 ani_object CommonFunAni::ConvertBundlePackInfo(ani_env* env, const BundlePackInfo& bundlePackInfo, const uint32_t flag)
1954 {
1955 RETURN_NULL_IF_NULL(env);
1956
1957 ani_class cls = CreateClassByName(env, CLASSNAME_BUNDLE_PACK_INFO_INNER);
1958 RETURN_NULL_IF_NULL(cls);
1959
1960 ani_object object = CreateNewObjectByClass(env, cls);
1961 RETURN_NULL_IF_NULL(object);
1962
1963 // packages: Array<PackageConfig>
1964 ani_object aPackageConfigObject = ConvertAniArray(env, bundlePackInfo.packages, ConvertPackages);
1965 RETURN_NULL_IF_NULL(aPackageConfigObject);
1966
1967 if (flag & BundlePackFlag::GET_PACKAGES) {
1968 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PACKAGES, aPackageConfigObject));
1969 return object;
1970 }
1971
1972 // summary: PackageSummary
1973 ani_object aPackageSummaryObject = ConvertSummary(env, bundlePackInfo.summary, true);
1974 RETURN_NULL_IF_NULL(aPackageSummaryObject);
1975
1976 if (flag & BundlePackFlag::GET_BUNDLE_SUMMARY) {
1977 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SUMMARY, aPackageSummaryObject));
1978 return object;
1979 }
1980
1981 if (flag & BundlePackFlag::GET_MODULE_SUMMARY) {
1982 ani_object aPackageSummaryWithoutApp = ConvertSummary(env, bundlePackInfo.summary, false);
1983 RETURN_NULL_IF_NULL(aPackageSummaryWithoutApp);
1984 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SUMMARY, aPackageSummaryWithoutApp));
1985 return object;
1986 }
1987
1988 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_PACKAGES, aPackageConfigObject));
1989 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_SUMMARY, aPackageSummaryObject));
1990
1991 return object;
1992 }
1993
CreateDispatchInfo(ani_env * env,const std::string & version,const std::string & dispatchAPIVersion)1994 ani_object CommonFunAni::CreateDispatchInfo(
1995 ani_env* env, const std::string& version, const std::string& dispatchAPIVersion)
1996 {
1997 RETURN_NULL_IF_NULL(env);
1998
1999 ani_class cls = CreateClassByName(env, CLASSNAME_DISPATCH_INFO_INNER);
2000 RETURN_NULL_IF_NULL(cls);
2001
2002 ani_object object = CreateNewObjectByClass(env, cls);
2003 RETURN_NULL_IF_NULL(object);
2004
2005 ani_string string = nullptr;
2006
2007 // version: string
2008 RETURN_NULL_IF_FALSE(StringToAniStr(env, version, string));
2009 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_VERSION, string));
2010
2011 // dispatchAPIVersion: string
2012 RETURN_NULL_IF_FALSE(StringToAniStr(env, dispatchAPIVersion, string));
2013 RETURN_NULL_IF_FALSE(CallSetter(env, cls, object, PROPERTYNAME_DISPATCHAPIVERSION, string));
2014
2015 return object;
2016 }
2017
ConvertWantInfo(ani_env * env,const Want & want)2018 ani_object CommonFunAni::ConvertWantInfo(ani_env* env, const Want& want)
2019 {
2020 RETURN_NULL_IF_NULL(env);
2021 ani_class cls = CreateClassByName(env, CLASSNAME_WANT);
2022 RETURN_NULL_IF_NULL(cls);
2023 ani_object object = CreateNewObjectByClass(env, cls);
2024 RETURN_NULL_IF_NULL(object);
2025 // bundleName?: string
2026 ani_string string = nullptr;
2027 if (StringToAniStr(env, want.GetElement().GetBundleName(), string)) {
2028 RETURN_NULL_IF_FALSE(CallSetField(env, cls, object, PROPERTYNAME_BUNDLENAME, string));
2029 }
2030 // abilityName?: string
2031 if (StringToAniStr(env, want.GetElement().GetAbilityName(), string)) {
2032 RETURN_NULL_IF_FALSE(CallSetField(env, cls, object, PROPERTYNAME_ABILITYNAME, string));
2033 }
2034 // deviceId?: string
2035 if (StringToAniStr(env, want.GetElement().GetDeviceID(), string)) {
2036 RETURN_NULL_IF_FALSE(CallSetField(env, cls, object, PROPERTYNAME_DEVICEID, string));
2037 }
2038 // action?: string
2039 if (StringToAniStr(env, want.GetAction(), string)) {
2040 RETURN_NULL_IF_FALSE(CallSetField(env, cls, object, PROPERTYNAME_ACTION, string));
2041 }
2042 // entities?: Array<string>
2043 auto entities = want.GetEntities();
2044 if (entities.size() > 0) {
2045 ani_object aEntities = ConvertAniArrayString(env, entities);
2046 RETURN_NULL_IF_NULL(aEntities);
2047 RETURN_NULL_IF_FALSE(CallSetField(env, cls, object, PROPERTYNAME_ENTITIES, aEntities));
2048 }
2049 // moduleName?: string
2050 if (StringToAniStr(env, want.GetElement().GetModuleName(), string)) {
2051 RETURN_NULL_IF_FALSE(CallSetField(env, cls, object, PROPERTYNAME_MODULENAME, string));
2052 }
2053 return object;
2054 }
2055
ParseShortcutInfo(ani_env * env,ani_object object,ShortcutInfo & shortcutInfo)2056 bool CommonFunAni::ParseShortcutInfo(ani_env* env, ani_object object, ShortcutInfo& shortcutInfo)
2057 {
2058 RETURN_FALSE_IF_NULL(env);
2059 RETURN_FALSE_IF_NULL(object);
2060
2061 ani_string string = nullptr;
2062 ani_int intValue = 0;
2063 uint32_t uintValue = 0;
2064
2065 // id: string
2066 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ID, &string));
2067 shortcutInfo.id = AniStrToString(env, string);
2068
2069 // bundleName: string
2070 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_BUNDLENAME, &string));
2071 shortcutInfo.bundleName = AniStrToString(env, string);
2072
2073 // moduleName?: string
2074 if (CallGetterOptional(env, object, PROPERTYNAME_MODULENAME, &string)) {
2075 shortcutInfo.moduleName = AniStrToString(env, string);
2076 }
2077
2078 // hostAbility?: string
2079 if (CallGetterOptional(env, object, PROPERTYNAME_HOSTABILITY, &string)) {
2080 shortcutInfo.hostAbility = AniStrToString(env, string);
2081 }
2082
2083 // icon?: string
2084 if (CallGetterOptional(env, object, PROPERTYNAME_ICON, &string)) {
2085 shortcutInfo.icon = AniStrToString(env, string);
2086 }
2087
2088 // iconId?: number
2089 if (CallGetterOptional(env, object, PROPERTYNAME_ICONID, &uintValue)) {
2090 shortcutInfo.iconId = uintValue;
2091 }
2092
2093 // label?: string
2094 if (CallGetterOptional(env, object, PROPERTYNAME_LABEL, &string)) {
2095 shortcutInfo.label = AniStrToString(env, string);
2096 }
2097
2098 // labelId?: number
2099 if (CallGetterOptional(env, object, PROPERTYNAME_LABELID, &uintValue)) {
2100 shortcutInfo.labelId = uintValue;
2101 }
2102
2103 // wants?: Array<ShortcutWant>
2104 ani_array array = nullptr;
2105 if (CallGetterOptional(env, object, PROPERTYNAME_WANTS, &array)) {
2106 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, shortcutInfo.intents, ParseShortcutIntent));
2107 }
2108
2109 // appIndex: number
2110 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_APPINDEX, &intValue));
2111 shortcutInfo.appIndex = intValue;
2112
2113 // sourceType: number
2114 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_SOURCETYPE, &intValue));
2115 shortcutInfo.sourceType = intValue;
2116
2117 ani_boolean boolValue = false;
2118 // visible?: boolean
2119 if (CallGetterOptional(env, object, PROPERTYNAME_VISIBLE, &boolValue)) {
2120 shortcutInfo.visible = boolValue;
2121 }
2122
2123 return true;
2124 }
2125
ParseShortcutIntent(ani_env * env,ani_object object,ShortcutIntent & shortcutIntent)2126 bool CommonFunAni::ParseShortcutIntent(ani_env* env, ani_object object, ShortcutIntent& shortcutIntent)
2127 {
2128 RETURN_FALSE_IF_NULL(env);
2129 RETURN_FALSE_IF_NULL(object);
2130
2131 ani_string string = nullptr;
2132
2133 // targetBundle: string
2134 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_TARGETBUNDLE, &string));
2135 shortcutIntent.targetBundle = AniStrToString(env, string);
2136
2137 // targetModule?: string
2138 if (CallGetterOptional(env, object, PROPERTYNAME_TARGETMODULE, &string)) {
2139 shortcutIntent.targetModule = AniStrToString(env, string);
2140 }
2141
2142 // targetAbility: string
2143 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_TARGETABILITY, &string));
2144 shortcutIntent.targetClass = AniStrToString(env, string);
2145
2146 // parameters?: Array<ParameterItem>
2147 ani_array array = nullptr;
2148 if (CallGetterOptional(env, object, PROPERTYNAME_PARAMETERS, &array)) {
2149 std::vector<std::pair<std::string, std::string>> parameters;
2150 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, parameters, ParseKeyValuePair));
2151 for (const auto& parameter : parameters) {
2152 shortcutIntent.parameters[parameter.first] = parameter.second;
2153 }
2154 }
2155
2156 return true;
2157 }
2158
ParseKeyValuePairWithName(ani_env * env,ani_object object,std::pair<std::string,std::string> & pair,const char * keyName,const char * valueName)2159 bool CommonFunAni::ParseKeyValuePairWithName(ani_env* env, ani_object object, std::pair<std::string, std::string>& pair,
2160 const char* keyName, const char* valueName)
2161 {
2162 RETURN_FALSE_IF_NULL(env);
2163 RETURN_FALSE_IF_NULL(object);
2164
2165 ani_string string = nullptr;
2166
2167 // key: string
2168 RETURN_FALSE_IF_FALSE(CallGetter(env, object, keyName, &string));
2169 pair.first = AniStrToString(env, string);
2170
2171 // value: string
2172 RETURN_FALSE_IF_FALSE(CallGetter(env, object, valueName, &string));
2173 pair.second = AniStrToString(env, string);
2174
2175 return true;
2176 }
2177
ParseKeyValuePair(ani_env * env,ani_object object,std::pair<std::string,std::string> & pair)2178 bool CommonFunAni::ParseKeyValuePair(ani_env* env, ani_object object, std::pair<std::string, std::string>& pair)
2179 {
2180 return ParseKeyValuePairWithName(env, object, pair, PROPERTYNAME_KEY, PROPERTYNAME_VALUE);
2181 }
2182
ParseHashParams(ani_env * env,ani_object object,std::pair<std::string,std::string> & pair)2183 bool CommonFunAni::ParseHashParams(ani_env* env, ani_object object, std::pair<std::string, std::string>& pair)
2184 {
2185 return ParseKeyValuePairWithName(env, object, pair, PROPERTYNAME_MODULENAME, PROPERTYNAME_HASHVALUE);
2186 }
2187
ParsePgoParams(ani_env * env,ani_object object,std::pair<std::string,std::string> & pair)2188 bool CommonFunAni::ParsePgoParams(ani_env* env, ani_object object, std::pair<std::string, std::string>& pair)
2189 {
2190 return ParseKeyValuePairWithName(env, object, pair, PROPERTYNAME_MODULENAME, PROPERTYNAME_PGOFILEPATH);
2191 }
2192
ParseInstallParam(ani_env * env,ani_object object,InstallParam & installParam)2193 bool CommonFunAni::ParseInstallParam(ani_env* env, ani_object object, InstallParam& installParam)
2194 {
2195 RETURN_FALSE_IF_NULL(env);
2196 RETURN_FALSE_IF_NULL(object);
2197
2198 ani_array array = nullptr;
2199 // hashParams?
2200 if (CallGetterOptional(env, object, PROPERTYNAME_HASHPARAMS, &array)) {
2201 std::vector<std::pair<std::string, std::string>> hashParams;
2202 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, hashParams, ParseHashParams));
2203 for (const auto& parameter : hashParams) {
2204 if (parameter.first.empty() || parameter.second.empty()) {
2205 APP_LOGE("key or value is empty");
2206 return false;
2207 }
2208 if (installParam.hashParams.find(parameter.first) != installParam.hashParams.end()) {
2209 APP_LOGE("duplicate key found");
2210 return false;
2211 }
2212 installParam.hashParams[parameter.first] = parameter.second;
2213 }
2214 }
2215
2216 // parameters?
2217 if (CallGetterOptional(env, object, PROPERTYNAME_PARAMETERS, &array)) {
2218 std::vector<std::pair<std::string, std::string>> parameters;
2219 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, parameters, ParseKeyValuePair));
2220 for (const auto& parameter : parameters) {
2221 installParam.parameters[parameter.first] = parameter.second;
2222 }
2223 }
2224
2225 // pgoParams?
2226 if (CallGetterOptional(env, object, PROPERTYNAME_PGOPARAMS, &array)) {
2227 std::vector<std::pair<std::string, std::string>> pgoParams;
2228 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, pgoParams, ParsePgoParams));
2229 for (const auto& parameter : pgoParams) {
2230 if (parameter.first.empty() || parameter.second.empty()) {
2231 APP_LOGE("key or value is empty");
2232 return false;
2233 }
2234 installParam.pgoParams[parameter.first] = parameter.second;
2235 }
2236 }
2237
2238 ani_int intValue = 0;
2239 // userId?: number
2240 if (CallGetterOptional(env, object, PROPERTYNAME_USERID, &intValue)) {
2241 installParam.userId = intValue;
2242 } else {
2243 APP_LOGW("Parse userId failed,using default value");
2244 }
2245 // installFlag?: number
2246 if (CallGetterOptional(env, object, PROPERTYNAME_INSTALLFLAG, &intValue)) {
2247 if ((intValue != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::NORMAL)) &&
2248 (intValue != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::REPLACE_EXISTING)) &&
2249 (intValue != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::FREE_INSTALL))) {
2250 APP_LOGE("invalid installFlag param");
2251 } else {
2252 installParam.installFlag = static_cast<OHOS::AppExecFwk::InstallFlag>(intValue);
2253 }
2254 } else {
2255 APP_LOGW("Parse installFlag failed,using default value");
2256 }
2257
2258 ani_boolean boolValue = false;
2259 // isKeepData?: boolean
2260 if (CallGetterOptional(env, object, PROPERTYNAME_ISKEEPDATA, &boolValue)) {
2261 installParam.isKeepData = boolValue;
2262 } else {
2263 APP_LOGW("Parse isKeepData failed,using default value");
2264 }
2265
2266 // crowdtestDeadline?: number
2267 if (CallGetterOptional(env, object, PROPERTYNAME_CROWDTESTDEADLINE, &intValue)) {
2268 installParam.crowdtestDeadline = intValue;
2269 } else {
2270 APP_LOGW("Parse crowdtestDeadline failed,using default value");
2271 }
2272
2273 // sharedBundleDirPaths?: Array<string>
2274 if (CallGetterOptional(env, object, PROPERTYNAME_SHAREDBUNDLEDIRPATHS, &array)) {
2275 RETURN_FALSE_IF_FALSE(ParseStrArray(env, array, installParam.sharedBundleDirPaths));
2276 }
2277
2278 ani_string string = nullptr;
2279
2280 // specifiedDistributionType?: string
2281 if (CallGetterOptional(env, object, PROPERTYNAME_SPECIFIEDDISTRIBUTIONTYPE, &string)) {
2282 installParam.specifiedDistributionType = AniStrToString(env, string);
2283 } else {
2284 APP_LOGW("Parse specifiedDistributionType failed,using default value");
2285 }
2286
2287 // additionalInfo?: string
2288 if (CallGetterOptional(env, object, PROPERTYNAME_ADDITIONALINFO, &string)) {
2289 installParam.additionalInfo = AniStrToString(env, string);
2290 } else {
2291 APP_LOGW("Parse additionalInfo failed,using default value");
2292 }
2293 return true;
2294 }
2295
ParseUninstallParam(ani_env * env,ani_object object,UninstallParam & uninstallParam)2296 bool CommonFunAni::ParseUninstallParam(ani_env* env, ani_object object, UninstallParam& uninstallParam)
2297 {
2298 RETURN_FALSE_IF_NULL(env);
2299 RETURN_FALSE_IF_NULL(object);
2300 ani_string string = nullptr;
2301 // bundleName: string
2302 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_BUNDLENAME, &string));
2303 uninstallParam.bundleName = AniStrToString(env, string);
2304 ani_int intValue = 0;
2305 // versionCode?: number
2306 if (CallGetterOptional(env, object, PROPERTYNAME_VERSIONCODE, &intValue)) {
2307 uninstallParam.versionCode = intValue;
2308 } else {
2309 APP_LOGW("Parse crowdtestDeadline failed,using default value");
2310 }
2311 return true;
2312 }
2313
ParseDestroyAppCloneParam(ani_env * env,ani_object object,DestroyAppCloneParam & destroyAppCloneParam)2314 bool CommonFunAni::ParseDestroyAppCloneParam(
2315 ani_env* env, ani_object object, DestroyAppCloneParam& destroyAppCloneParam)
2316 {
2317 RETURN_FALSE_IF_NULL(env);
2318 RETURN_FALSE_IF_NULL(object);
2319 ani_int intValue = 0;
2320 // userId?: number
2321 if (CallGetterOptional(env, object, PROPERTYNAME_USERID, &intValue)) {
2322 destroyAppCloneParam.userId = intValue;
2323 } else {
2324 destroyAppCloneParam.userId = Constants::UNSPECIFIED_USERID;
2325 APP_LOGW("Parse userId failed,using default value");
2326 }
2327 ani_array array = nullptr;
2328 // parameters?
2329 if (CallGetterOptional(env, object, PROPERTYNAME_PARAMETERS, &array)) {
2330 std::vector<std::pair<std::string, std::string>> parameters;
2331 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, parameters, ParseKeyValuePair));
2332 for (const auto& parameter : parameters) {
2333 destroyAppCloneParam.parameters[parameter.first] = parameter.second;
2334 }
2335 }
2336 return true;
2337 }
2338
ParsePluginParam(ani_env * env,ani_object object,InstallPluginParam & installPluginParam)2339 bool CommonFunAni::ParsePluginParam(ani_env* env, ani_object object, InstallPluginParam& installPluginParam)
2340 {
2341 RETURN_FALSE_IF_NULL(env);
2342 RETURN_FALSE_IF_NULL(object);
2343
2344 ani_int intValue = 0;
2345 ani_array array = nullptr;
2346
2347 // userId?: number
2348 if (CallGetterOptional(env, object, PROPERTYNAME_USERID, &intValue)) {
2349 installPluginParam.userId = intValue;
2350 } else {
2351 installPluginParam.userId = Constants::UNSPECIFIED_USERID;
2352 APP_LOGW("Parse userId failed, using default value");
2353 }
2354
2355 // parameters?
2356 if (CallGetterOptional(env, object, PROPERTYNAME_PARAMETERS, &array)) {
2357 std::vector<std::pair<std::string, std::string>> parameters;
2358 RETURN_FALSE_IF_FALSE(ParseAniArray(env, array, parameters, ParseKeyValuePair));
2359 for (const auto& parameter : parameters) {
2360 installPluginParam.parameters[parameter.first] = parameter.second;
2361 }
2362 }
2363
2364 return true;
2365 }
2366
ParseCreateAppCloneParam(ani_env * env,ani_object object,int32_t & userId,int32_t & appIdx)2367 bool CommonFunAni::ParseCreateAppCloneParam(ani_env* env, ani_object object, int32_t& userId, int32_t& appIdx)
2368 {
2369 RETURN_FALSE_IF_NULL(env);
2370 RETURN_FALSE_IF_NULL(object);
2371 ani_int intValue = 0;
2372 // userId?: number
2373 if (CallGetterOptional(env, object, PROPERTYNAME_USERID, &intValue)) {
2374 userId = intValue;
2375 } else {
2376 userId = Constants::UNSPECIFIED_USERID;
2377 APP_LOGW("Parse userId failed,using default value");
2378 }
2379
2380 // appIdx?: number
2381 if (CallGetterOptional(env, object, PROPERTYNAME_APPINDEX, &intValue)) {
2382 appIdx = intValue;
2383 } else {
2384 appIdx = Constants::INITIAL_APP_INDEX;
2385 APP_LOGW("Parse appIdx failed,using default value");
2386 }
2387 return true;
2388 }
2389
ParseMetadata(ani_env * env,ani_object object,Metadata & metadata)2390 bool CommonFunAni::ParseMetadata(ani_env* env, ani_object object, Metadata& metadata)
2391 {
2392 RETURN_FALSE_IF_NULL(env);
2393 RETURN_FALSE_IF_NULL(object);
2394
2395 ani_string string = nullptr;
2396 uint32_t uintValue = 0;
2397
2398 // name: string
2399 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_NAME, &string));
2400 metadata.name = AniStrToString(env, string);
2401
2402 // value: string
2403 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_VALUE, &string));
2404 metadata.value = AniStrToString(env, string);
2405
2406 // resource: string
2407 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_RESOURCE, &string));
2408 metadata.resource = AniStrToString(env, string);
2409
2410 // valueId?: number
2411 if (CallGetterOptional(env, object, PROPERTYNAME_VALUEID, &uintValue)) {
2412 metadata.valueId = uintValue;
2413 }
2414
2415 return true;
2416 }
2417
ParseResource(ani_env * env,ani_object object,Resource & resource)2418 bool CommonFunAni::ParseResource(ani_env* env, ani_object object, Resource& resource)
2419 {
2420 RETURN_FALSE_IF_NULL(env);
2421 RETURN_FALSE_IF_NULL(object);
2422
2423 ani_string string = nullptr;
2424 uint32_t uintValue = 0;
2425
2426 // bundleName: string
2427 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_BUNDLENAME, &string));
2428 resource.bundleName = AniStrToString(env, string);
2429
2430 // moduleName: string
2431 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MODULENAME, &string));
2432 resource.moduleName = AniStrToString(env, string);
2433
2434 // id: number
2435 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ID, &uintValue));
2436 resource.id = uintValue;
2437
2438 return true;
2439 }
2440
ParseMultiAppMode(ani_env * env,ani_object object,MultiAppModeData & multiAppMode)2441 bool CommonFunAni::ParseMultiAppMode(ani_env* env, ani_object object, MultiAppModeData& multiAppMode)
2442 {
2443 RETURN_FALSE_IF_NULL(env);
2444 RETURN_FALSE_IF_NULL(object);
2445
2446 ani_enum_item enumItem = nullptr;
2447 ani_int intValue = 0;
2448
2449 // maxCount: number
2450 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MAXCOUNT, &intValue));
2451 multiAppMode.maxCount = intValue;
2452
2453 // multiAppModeType: bundleManager.MultiAppModeType
2454 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MULTIAPPMODETYPE, &enumItem));
2455 RETURN_FALSE_IF_FALSE(EnumUtils::EnumETSToNative(env, enumItem, multiAppMode.multiAppModeType));
2456
2457 return true;
2458 }
2459
ParseApplicationInfo(ani_env * env,ani_object object,ApplicationInfo & appInfo)2460 bool CommonFunAni::ParseApplicationInfo(ani_env* env, ani_object object, ApplicationInfo& appInfo)
2461 {
2462 RETURN_FALSE_IF_NULL(env);
2463 RETURN_FALSE_IF_NULL(object);
2464
2465 ani_string string = nullptr;
2466 // name: string
2467 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_NAME, &string));
2468 appInfo.name = AniStrToString(env, string);
2469
2470 // description: string
2471 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DESCRIPTION, &string));
2472 appInfo.description = AniStrToString(env, string);
2473
2474 uint32_t uintValue = 0;
2475 // descriptionId: number
2476 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DESCRIPTIONID, &uintValue));
2477 appInfo.descriptionId = uintValue;
2478
2479 ani_boolean boolValue = ANI_FALSE;
2480 // enabled: boolean
2481 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ENABLED, &boolValue));
2482 appInfo.enabled = AniBooleanToBool(boolValue);
2483
2484 // label: string
2485 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LABEL, &string));
2486 appInfo.label = AniStrToString(env, string);
2487
2488 // labelId: number
2489 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LABELID, &uintValue));
2490 appInfo.labelId = uintValue;
2491
2492 // icon: string
2493 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ICON, &string));
2494 appInfo.iconPath = AniStrToString(env, string);
2495
2496 // iconId: number
2497 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ICONID, &uintValue));
2498 appInfo.iconId = uintValue;
2499
2500 // process: string
2501 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PROCESS, &string));
2502 appInfo.process = AniStrToString(env, string);
2503
2504 ani_object arrayObject = nullptr;
2505 // permissions: Array<string>
2506 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PERMISSIONS, &arrayObject));
2507 RETURN_FALSE_IF_FALSE(ParseStrArray(env, arrayObject, appInfo.permissions));
2508
2509 // codePath: string
2510 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_CODEPATH, &string));
2511 appInfo.codePath = AniStrToString(env, string);
2512
2513 // metadataArray: Array<ModuleMetadata>
2514 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_METADATAARRAY, &arrayObject));
2515 RETURN_FALSE_IF_FALSE(AniArrayForeach(env, arrayObject, [env, &appInfo](ani_object itemModuleMetadataANI) {
2516 // moduleName: string
2517 ani_string stringValue = nullptr;
2518 RETURN_FALSE_IF_FALSE(CallGetter(env, itemModuleMetadataANI, PROPERTYNAME_MODULENAME, &stringValue));
2519 std::string key = AniStrToString(env, stringValue);
2520 RETURN_FALSE_IF_FALSE(!key.empty());
2521
2522 // metadata: Array<Metadata>
2523 ani_object arrayMetadataANI = nullptr;
2524 RETURN_FALSE_IF_FALSE(CallGetter(env, itemModuleMetadataANI, PROPERTYNAME_METADATA, &arrayMetadataANI));
2525 std::vector<Metadata> arrayMetadataNative;
2526 RETURN_FALSE_IF_FALSE(ParseAniArray(env, arrayMetadataANI, arrayMetadataNative, ParseMetadata));
2527
2528 appInfo.metadata.emplace(key, std::move(arrayMetadataNative));
2529
2530 return true;
2531 }));
2532
2533 // removable: boolean
2534 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_REMOVABLE, &boolValue));
2535 appInfo.removable = AniBooleanToBool(boolValue);
2536
2537 // accessTokenId: number
2538 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ACCESSTOKENID, &uintValue));
2539 appInfo.accessTokenId = uintValue;
2540
2541 ani_int intValue = 0;
2542 // uid: number
2543 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_UID, &intValue));
2544 appInfo.uid = intValue;
2545
2546 ani_object aniObject = nullptr;
2547 // iconResource: Resource
2548 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ICONRESOURCE, &aniObject));
2549 RETURN_FALSE_IF_FALSE(ParseResource(env, aniObject, appInfo.iconResource));
2550
2551 // labelResource: Resource
2552 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LABELRESOURCE, &aniObject));
2553 RETURN_FALSE_IF_FALSE(ParseResource(env, aniObject, appInfo.labelResource));
2554
2555 // descriptionResource: Resource
2556 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DESCRIPTIONRESOURCE, &aniObject));
2557 RETURN_FALSE_IF_FALSE(ParseResource(env, aniObject, appInfo.descriptionResource));
2558
2559 // appDistributionType: string
2560 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_APPDISTRIBUTIONTYPE, &string));
2561 appInfo.appDistributionType = AniStrToString(env, string);
2562
2563 // appProvisionType: string
2564 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_APPPROVISIONTYPE, &string));
2565 appInfo.appProvisionType = AniStrToString(env, string);
2566
2567 // systemApp: boolean
2568 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_SYSTEMAPP, &boolValue));
2569 appInfo.isSystemApp = AniBooleanToBool(boolValue);
2570
2571 ani_enum_item enumItem = nullptr;
2572 // bundleType: bundleManager.BundleType
2573 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_BUNDLETYPE, &enumItem));
2574 RETURN_FALSE_IF_FALSE(EnumUtils::EnumETSToNative(env, enumItem, appInfo.bundleType));
2575
2576 // debug: boolean
2577 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DEBUG, &boolValue));
2578 appInfo.debug = AniBooleanToBool(boolValue);
2579
2580 // dataUnclearable: boolean
2581 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DATAUNCLEARABLE, &boolValue));
2582 appInfo.userDataClearable = AniBooleanToBool(!boolValue);
2583
2584 // nativeLibraryPath: string
2585 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_NATIVELIBRARYPATH, &string));
2586 appInfo.nativeLibraryPath = AniStrToString(env, string);
2587
2588 // multiAppMode: MultiAppMode
2589 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MULTIAPPMODE, &aniObject));
2590 RETURN_FALSE_IF_FALSE(ParseMultiAppMode(env, aniObject, appInfo.multiAppMode));
2591
2592 // appIndex: number
2593 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_APPINDEX, &intValue));
2594 appInfo.appIndex = intValue;
2595
2596 // installSource: string
2597 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_INSTALLSOURCE, &string));
2598 appInfo.installSource = AniStrToString(env, string);
2599
2600 // releaseType: string
2601 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_RELEASETYPE, &string));
2602 appInfo.apiReleaseType = AniStrToString(env, string);
2603
2604 // cloudFileSyncEnabled: boolean
2605 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_CLOUDFILESYNCENABLED, &boolValue));
2606 appInfo.cloudFileSyncEnabled = AniBooleanToBool(boolValue);
2607
2608 // flags?: number
2609 if (CallGetterOptional(env, object, PROPERTYNAME_FLAGS, &intValue)) {
2610 appInfo.flags = intValue;
2611 }
2612
2613 return true;
2614 }
2615
ParseWindowSize(ani_env * env,ani_object object,AbilityInfo & abilityInfo)2616 bool CommonFunAni::ParseWindowSize(ani_env* env, ani_object object, AbilityInfo& abilityInfo)
2617 {
2618 RETURN_FALSE_IF_NULL(env);
2619 RETURN_FALSE_IF_NULL(object);
2620
2621 ani_double doubleValue = 0;
2622 uint32_t uintValue = 0;
2623
2624 // maxWindowRatio: number
2625 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MAXWINDOWRATIO, &doubleValue));
2626 abilityInfo.maxWindowRatio = doubleValue;
2627
2628 // minWindowRatio: number
2629 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MINWINDOWRATIO, &doubleValue));
2630 abilityInfo.minWindowRatio = doubleValue;
2631
2632 // maxWindowWidth: number
2633 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MAXWINDOWWIDTH, &uintValue));
2634 abilityInfo.maxWindowWidth = uintValue;
2635
2636 // minWindowWidth: number
2637 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MINWINDOWWIDTH, &uintValue));
2638 abilityInfo.minWindowWidth = uintValue;
2639
2640 // maxWindowHeight: number
2641 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MAXWINDOWHEIGHT, &uintValue));
2642 abilityInfo.maxWindowHeight = uintValue;
2643
2644 // minWindowHeight: number
2645 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MINWINDOWHEIGHT, &uintValue));
2646 abilityInfo.minWindowHeight = uintValue;
2647
2648 return object;
2649 }
2650
ParseAbilitySkillUriInner(ani_env * env,ani_object object,SkillUri & skillUri,bool isExtension)2651 bool CommonFunAni::ParseAbilitySkillUriInner(ani_env* env, ani_object object, SkillUri& skillUri, bool isExtension)
2652 {
2653 RETURN_FALSE_IF_NULL(env);
2654 RETURN_FALSE_IF_NULL(object);
2655
2656 ani_string string = nullptr;
2657 ani_int intValue = 0;
2658
2659 // scheme: string
2660 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_SCHEME, &string));
2661 skillUri.scheme = AniStrToString(env, string);
2662
2663 // host: string
2664 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_HOST, &string));
2665 skillUri.host = AniStrToString(env, string);
2666
2667 // port: number
2668 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PORT, &intValue));
2669 skillUri.port = std::to_string(intValue);
2670
2671 // path: string
2672 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PATH, &string));
2673 skillUri.path = AniStrToString(env, string);
2674
2675 // pathStartWith: string
2676 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PATHSTARTWITH, &string));
2677 skillUri.pathStartWith = AniStrToString(env, string);
2678
2679 // pathRegex: string
2680 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PATHREGEX, &string));
2681 skillUri.pathRegex = AniStrToString(env, string);
2682
2683 // type: string
2684 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_TYPE, &string));
2685 skillUri.type = AniStrToString(env, string);
2686
2687 // utd: string
2688 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_UTD, &string));
2689 skillUri.utd = AniStrToString(env, string);
2690
2691 // maxFileSupported: number
2692 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MAXFILESUPPORTED, &intValue));
2693 skillUri.maxFileSupported = intValue;
2694
2695 if (!isExtension) {
2696 // linkFeature: string
2697 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LINKFEATURE, &string));
2698 skillUri.linkFeature = AniStrToString(env, string);
2699 }
2700
2701 return true;
2702 }
2703
ParseAbilitySkillInner(ani_env * env,ani_object object,Skill & skill,bool isExtension)2704 bool CommonFunAni::ParseAbilitySkillInner(ani_env* env, ani_object object, Skill& skill, bool isExtension)
2705 {
2706 RETURN_FALSE_IF_NULL(env);
2707 RETURN_FALSE_IF_NULL(object);
2708
2709 ani_object arrayObject = nullptr;
2710 ani_boolean boolValue = ANI_FALSE;
2711
2712 // actions: Array<string>
2713 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ACTIONS, &arrayObject));
2714 RETURN_FALSE_IF_FALSE(ParseStrArray(env, arrayObject, skill.actions));
2715
2716 // entities: Array<string>
2717 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ENTITIES, &arrayObject));
2718 RETURN_FALSE_IF_FALSE(ParseStrArray(env, arrayObject, skill.entities));
2719
2720 // uris: Array<SkillUri>
2721 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_URIS, &arrayObject));
2722 RETURN_FALSE_IF_FALSE(ParseAniArray(
2723 env, arrayObject, skill.uris, isExtension ? ParseExtensionAbilitySkillUri : ParseAbilitySkillUri));
2724
2725 if (!isExtension) {
2726 // domainVerify: boolean
2727 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DOMAINVERIFY, &boolValue));
2728 skill.domainVerify = AniBooleanToBool(boolValue);
2729 }
2730
2731 return true;
2732 }
2733
ParseAbilityInfo(ani_env * env,ani_object object,AbilityInfo & abilityInfo)2734 bool CommonFunAni::ParseAbilityInfo(ani_env* env, ani_object object, AbilityInfo& abilityInfo)
2735 {
2736 RETURN_FALSE_IF_NULL(env);
2737 RETURN_FALSE_IF_NULL(object);
2738
2739 ani_string string = nullptr;
2740 // bundleName: string
2741 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_BUNDLENAME, &string));
2742 abilityInfo.bundleName = AniStrToString(env, string);
2743
2744 // moduleName: string
2745 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_MODULENAME, &string));
2746 abilityInfo.moduleName = AniStrToString(env, string);
2747
2748 // name: string
2749 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_NAME, &string));
2750 abilityInfo.name = AniStrToString(env, string);
2751
2752 // label: string
2753 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LABEL, &string));
2754 abilityInfo.label = AniStrToString(env, string);
2755
2756 uint32_t uintValue = 0;
2757 // labelId: number
2758 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LABELID, &uintValue));
2759 abilityInfo.labelId = uintValue;
2760
2761 // description: string
2762 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DESCRIPTION, &string));
2763 abilityInfo.description = AniStrToString(env, string);
2764
2765 // descriptionId: number
2766 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DESCRIPTIONID, &uintValue));
2767 abilityInfo.descriptionId = uintValue;
2768
2769 // icon: string
2770 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ICON, &string));
2771 abilityInfo.iconPath = AniStrToString(env, string);
2772
2773 // iconId: number
2774 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ICONID, &uintValue));
2775 abilityInfo.iconId = uintValue;
2776
2777 // process: string
2778 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PROCESS, &string));
2779 abilityInfo.process = AniStrToString(env, string);
2780
2781 ani_boolean boolValue = ANI_FALSE;
2782 // exported: boolean
2783 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_EXPORTED, &boolValue));
2784 abilityInfo.visible = AniBooleanToBool(boolValue);
2785
2786 ani_enum_item enumItem = nullptr;
2787 // orientation: bundleManager.DisplayOrientation
2788 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ORIENTATION, &enumItem));
2789 RETURN_FALSE_IF_FALSE(EnumUtils::EnumETSToNative(env, enumItem, abilityInfo.orientation));
2790
2791 // launchType: bundleManager.LaunchType
2792 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_LAUNCHTYPE, &enumItem));
2793 RETURN_FALSE_IF_FALSE(EnumUtils::EnumETSToNative(env, enumItem, abilityInfo.launchMode));
2794
2795 ani_object arrayObject = nullptr;
2796 // permissions: Array<string>
2797 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_PERMISSIONS, &arrayObject));
2798 RETURN_FALSE_IF_FALSE(ParseStrArray(env, arrayObject, abilityInfo.permissions));
2799
2800 // deviceTypes: Array<string>
2801 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_DEVICETYPES, &arrayObject));
2802 RETURN_FALSE_IF_FALSE(ParseStrArray(env, arrayObject, abilityInfo.deviceTypes));
2803
2804 ani_object aniObject = nullptr;
2805 // applicationInfo: ApplicationInfo
2806 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_APPLICATIONINFO, &aniObject));
2807 RETURN_FALSE_IF_FALSE(ParseApplicationInfo(env, aniObject, abilityInfo.applicationInfo));
2808
2809 // metadata: Array<Metadata>
2810 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_METADATA, &arrayObject));
2811 RETURN_FALSE_IF_FALSE(ParseAniArray(env, arrayObject, abilityInfo.metadata, ParseMetadata));
2812
2813 // enabled: boolean
2814 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ENABLED, &boolValue));
2815 abilityInfo.enabled = AniBooleanToBool(boolValue);
2816
2817 // supportWindowModes: Array<bundleManager.SupportWindowMode>
2818 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_SUPPORTWINDOWMODES, &arrayObject));
2819 RETURN_FALSE_IF_FALSE(ParseEnumArray(env, arrayObject, abilityInfo.windowModes));
2820
2821 // windowSize: WindowSize
2822 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_WINDOWSIZE, &aniObject));
2823 RETURN_FALSE_IF_FALSE(ParseWindowSize(env, aniObject, abilityInfo));
2824
2825 // excludeFromDock: boolean
2826 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_EXCLUDEFROMDOCK, &boolValue));
2827 abilityInfo.excludeFromDock = AniBooleanToBool(boolValue);
2828
2829 // skills: Array<Skill>
2830 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_SKILLS, &arrayObject));
2831 RETURN_FALSE_IF_FALSE(ParseAniArray(env, arrayObject, abilityInfo.skills, ParseAbilitySkill));
2832
2833 ani_int intValue = 0;
2834 // appIndex: number
2835 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_APPINDEX, &intValue));
2836 abilityInfo.appIndex = intValue;
2837
2838 // orientationId: number
2839 RETURN_FALSE_IF_FALSE(CallGetter(env, object, PROPERTYNAME_ORIENTATIONID, &uintValue));
2840 abilityInfo.orientationId = uintValue;
2841
2842 return true;
2843 }
2844 } // namespace AppExecFwk
2845 } // namespace OHOS