1 /*
2 * Copyright (c) 2024 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 <cstdint>
17 #include <string>
18
19 #include "bundle_manager_utils.h"
20 #include "ipc_skeleton.h"
21 #include "bundle_info.h"
22 #include "bundle_mgr_proxy.h"
23 #include "common_func.h"
24 #include "bundle_manager_convert.h"
25 #include "app_log_wrapper.h"
26
27 namespace OHOS {
28 namespace CJSystemapi {
29 namespace BundleManager {
30 namespace Convert {
31
32 const std::string PATH_PREFIX = "/data/app/el1/bundle/public";
33 const std::string CODE_PATH_PREFIX = "/data/storage/el1/bundle/";
34 const std::string CONTEXT_DATA_STORAGE_BUNDLE("/data/storage/el1/bundle/");
35
MallocCString(const std::string & origin)36 char *MallocCString(const std::string &origin)
37 {
38 if (origin.empty()) {
39 return nullptr;
40 }
41 auto len = origin.length() + 1;
42 char* res = static_cast<char *>(malloc(sizeof(char) * len));
43 if (res == nullptr) {
44 APP_LOGE("MallocCString malloc failed");
45 return nullptr;
46 }
47 return std::char_traits<char>::copy(res, origin.c_str(), len);
48 }
49
ClearCharPointer(char ** ptr,int count)50 void ClearCharPointer(char** ptr, int count)
51 {
52 for (int i = 0; i < count; i++) {
53 free(ptr[i]);
54 ptr[i] = nullptr;
55 }
56 }
57
ConvertArrString(std::vector<std::string> vecStr)58 CArrString ConvertArrString(std::vector<std::string> vecStr)
59 {
60 if (vecStr.size() == 0) {
61 return {nullptr, 0};
62 }
63 char **retValue = static_cast<char **>(malloc(sizeof(char *) * vecStr.size()));
64 if (retValue == nullptr) {
65 return {nullptr, 0};
66 }
67
68 for (size_t i = 0; i < vecStr.size(); i++) {
69 retValue[i] = MallocCString(vecStr[i]);
70 if (retValue[i] == nullptr) {
71 ClearCharPointer(retValue, i);
72 free(retValue);
73 return {nullptr, 0};
74 }
75 }
76
77 return {retValue, vecStr.size()};
78 }
79
ConvertUsedScene(const AppExecFwk::RequestPermissionUsedScene & usedScence)80 RetUsedScene ConvertUsedScene(const AppExecFwk::RequestPermissionUsedScene& usedScence)
81 {
82 RetUsedScene uScene;
83 uScene.abilities = ConvertArrString(usedScence.abilities);
84 uScene.when = MallocCString(usedScence.when);
85 return uScene;
86 }
87
ConvertMetadata(const AppExecFwk::Metadata & cData)88 RetMetadata ConvertMetadata(const AppExecFwk::Metadata& cData)
89 {
90 RetMetadata data;
91 data.name = MallocCString(cData.name);
92 data.value = MallocCString(cData.value);
93 data.resource = MallocCString(cData.resource);
94 return data;
95 }
96
ConvertResource(const AppExecFwk::Resource & cRes)97 CResource ConvertResource(const AppExecFwk::Resource& cRes)
98 {
99 CResource res;
100 res.bundleName = MallocCString(cRes.bundleName);
101 res.moduleName = MallocCString(cRes.moduleName);
102 res.id = cRes.id;
103 return res;
104 }
105
ConvertArrMetadata(const std::vector<AppExecFwk::Metadata> & cData)106 CArrMetadata ConvertArrMetadata(const std::vector<AppExecFwk::Metadata>& cData)
107 {
108 CArrMetadata data;
109 data.size = static_cast<int64_t>(cData.size());
110 data.head = nullptr;
111 if (data.size > 0) {
112 RetMetadata *retValue = reinterpret_cast<RetMetadata *>(malloc(sizeof(RetMetadata) * data.size));
113 if (retValue != nullptr) {
114 for (int32_t i = 0; i < data.size; i++) {
115 retValue[i] = ConvertMetadata(cData[i]);
116 }
117 data.head = retValue;
118 } else {
119 APP_LOGE("ConvertArrMetadata malloc failed");
120 return data;
121 }
122 }
123 return data;
124 }
125
ConvertArrMoMeta(const std::map<std::string,std::vector<AppExecFwk::Metadata>> & metadata)126 CArrMoMeta ConvertArrMoMeta(const std::map<std::string, std::vector<AppExecFwk::Metadata>>& metadata)
127 {
128 CArrMoMeta arrMdata;
129 arrMdata.size = static_cast<int64_t>(metadata.size());
130 arrMdata.head = nullptr;
131 if (arrMdata.size > 0) {
132 ModuleMetadata* retValue = reinterpret_cast<ModuleMetadata *>(malloc(sizeof(ModuleMetadata) * arrMdata.size));
133 if (retValue != nullptr) {
134 int32_t i = 0;
135 for (const auto &item : metadata) {
136 retValue[i].moduleName = MallocCString(item.first);
137 retValue[i++].metadata = ConvertArrMetadata(item.second);
138 }
139 } else {
140 APP_LOGE("ConvertArrMoMeta malloc failed");
141 return arrMdata;
142 }
143 arrMdata.head = retValue;
144 }
145 return arrMdata;
146 }
147
148
ConvertSkillUri(const AppExecFwk::SkillUri & cUri)149 RetSkillUri ConvertSkillUri(const AppExecFwk::SkillUri& cUri)
150 {
151 RetSkillUri skillUri;
152 skillUri.scheme = MallocCString(cUri.scheme);
153 skillUri.host = MallocCString(cUri.host);
154 skillUri.port = MallocCString(cUri.port);
155 skillUri.path = MallocCString(cUri.path);
156 skillUri.pathStartWith = MallocCString(cUri.pathStartWith);
157 skillUri.pathRegex = MallocCString(cUri.pathRegex);
158 skillUri.type = MallocCString(cUri.type);
159 skillUri.utd = MallocCString(cUri.utd);
160 skillUri.maxFileSupported = cUri.maxFileSupported;
161 skillUri.linkFeature = MallocCString(cUri.linkFeature);
162 return skillUri;
163 }
164
ConvertArrSkillUris(const std::vector<AppExecFwk::SkillUri> & cUris)165 RetCArrSkillUri ConvertArrSkillUris(const std::vector<AppExecFwk::SkillUri>& cUris)
166 {
167 RetCArrSkillUri skillUris;
168 skillUris.size = static_cast<int64_t>(cUris.size());
169 skillUris.head = nullptr;
170
171 if (skillUris.size == 0) {
172 return skillUris;
173 }
174 RetSkillUri *retValue = reinterpret_cast<RetSkillUri *>(malloc(sizeof(RetSkillUri) * skillUris.size));
175 if (retValue != nullptr) {
176 for (int32_t i = 0; i < skillUris.size; i++) {
177 retValue[i] = ConvertSkillUri(cUris[i]);
178 }
179 skillUris.head = retValue;
180 } else {
181 APP_LOGE("ConvertArrSkillUris malloc failed");
182 return skillUris;
183 }
184 return skillUris;
185 }
186
ConvertSkill(const AppExecFwk::Skill & cSkill)187 RetSkill ConvertSkill(const AppExecFwk::Skill& cSkill)
188 {
189 RetSkill skill;
190 skill.actions = ConvertArrString(cSkill.actions);
191 skill.entities = ConvertArrString(cSkill.entities);
192 skill.uris = ConvertArrSkillUris(cSkill.uris);
193 skill.domainVerify = cSkill.domainVerify;
194 return skill;
195 }
196
ConvertSkills(const std::vector<AppExecFwk::Skill> & cSkills)197 RetCArrSkill ConvertSkills(const std::vector<AppExecFwk::Skill>& cSkills)
198 {
199 RetCArrSkill skills;
200 skills.size = static_cast<int64_t>(cSkills.size());
201 skills.head = nullptr;
202 if (skills.size == 0) {
203 return skills;
204 }
205 RetSkill *retValue = reinterpret_cast<RetSkill *>(malloc(sizeof(RetSkill) * skills.size));
206 if (retValue != nullptr) {
207 for (int32_t i = 0; i < skills.size; i++) {
208 retValue[i] = ConvertSkill(cSkills[i]);
209 }
210 skills.head = retValue;
211 } else {
212 APP_LOGE("ConvertSkills malloc failed");
213 return skills;
214 }
215 return skills;
216 }
217
ConvertRequestPermission(const AppExecFwk::RequestPermission & requestPermission)218 RetReqPermissionDetail ConvertRequestPermission(const AppExecFwk::RequestPermission& requestPermission)
219 {
220 RetReqPermissionDetail reqPer;
221 reqPer.name = MallocCString(requestPermission.name);
222 reqPer.moduleName = MallocCString(requestPermission.moduleName);
223 reqPer.reason = MallocCString(requestPermission.reason);
224 reqPer.reasonId = requestPermission.reasonId;
225 reqPer.usedScence = ConvertUsedScene(requestPermission.usedScene);
226 return reqPer;
227 }
228
ConvertApplicationInfo(const AppExecFwk::ApplicationInfo & cAppInfo)229 RetApplicationInfo ConvertApplicationInfo(const AppExecFwk::ApplicationInfo& cAppInfo)
230 {
231 RetApplicationInfo appInfo;
232 appInfo.name = MallocCString(cAppInfo.name);
233 appInfo.description = MallocCString(cAppInfo.description);
234 appInfo.descriptionId = cAppInfo.descriptionId;
235 appInfo.enabled = cAppInfo.enabled;
236 appInfo.label = MallocCString(cAppInfo.label);
237 appInfo.labelId = cAppInfo.labelId;
238 appInfo.icon = MallocCString(cAppInfo.iconPath);
239 appInfo.iconId = cAppInfo.iconId;
240 appInfo.process = MallocCString(cAppInfo.process);
241
242 appInfo.permissions = ConvertArrString(cAppInfo.permissions);
243
244 appInfo.codePath = MallocCString(cAppInfo.codePath);
245
246 appInfo.metadataArray = ConvertArrMoMeta(cAppInfo.metadata);
247
248 appInfo.removable = cAppInfo.removable;
249 appInfo.accessTokenId = cAppInfo.accessTokenId;
250 appInfo.uid = cAppInfo.uid;
251
252 appInfo.iconResource = ConvertResource(cAppInfo.iconResource);
253 appInfo.labelResource = ConvertResource(cAppInfo.labelResource);
254 appInfo.descriptionResource = ConvertResource(cAppInfo.descriptionResource);
255
256 appInfo.appDistributionType = MallocCString(cAppInfo.appDistributionType);
257 appInfo.appProvisionType = MallocCString(cAppInfo.appProvisionType);
258 appInfo.systemApp = cAppInfo.isSystemApp;
259 appInfo.bundleType = static_cast<int32_t>(cAppInfo.bundleType);
260 appInfo.debug = cAppInfo.debug;
261 appInfo.dataUnclearable = !cAppInfo.userDataClearable;
262 appInfo.cloudFileSyncEnabled = cAppInfo.cloudFileSyncEnabled;
263 return appInfo;
264 }
265
ConvertApplicationInfoV2(const AppExecFwk::ApplicationInfo & cAppInfo)266 RetApplicationInfoV2 ConvertApplicationInfoV2(const AppExecFwk::ApplicationInfo& cAppInfo)
267 {
268 RetApplicationInfoV2 appInfo;
269 appInfo.name = MallocCString(cAppInfo.name);
270 appInfo.description = MallocCString(cAppInfo.description);
271 appInfo.descriptionId = cAppInfo.descriptionId;
272 appInfo.enabled = cAppInfo.enabled;
273 appInfo.label = MallocCString(cAppInfo.label);
274 appInfo.labelId = cAppInfo.labelId;
275 appInfo.icon = MallocCString(cAppInfo.iconPath);
276 appInfo.iconId = cAppInfo.iconId;
277 appInfo.process = MallocCString(cAppInfo.process);
278
279 appInfo.permissions = ConvertArrString(cAppInfo.permissions);
280
281 appInfo.codePath = MallocCString(cAppInfo.codePath);
282
283 appInfo.metadataArray = ConvertArrMoMeta(cAppInfo.metadata);
284
285 appInfo.removable = cAppInfo.removable;
286 appInfo.accessTokenId = cAppInfo.accessTokenId;
287 appInfo.uid = cAppInfo.uid;
288
289 appInfo.iconResource = ConvertResource(cAppInfo.iconResource);
290 appInfo.labelResource = ConvertResource(cAppInfo.labelResource);
291 appInfo.descriptionResource = ConvertResource(cAppInfo.descriptionResource);
292
293 appInfo.appDistributionType = MallocCString(cAppInfo.appDistributionType);
294 appInfo.appProvisionType = MallocCString(cAppInfo.appProvisionType);
295 appInfo.systemApp = cAppInfo.isSystemApp;
296 appInfo.bundleType = static_cast<int32_t>(cAppInfo.bundleType);
297 appInfo.debug = cAppInfo.debug;
298 appInfo.dataUnclearable = !cAppInfo.userDataClearable;
299 appInfo.cloudFileSyncEnabled = cAppInfo.cloudFileSyncEnabled;
300 std::string externalNativeLibraryPath = "";
301 if (!cAppInfo.nativeLibraryPath.empty()) {
302 externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + cAppInfo.nativeLibraryPath;
303 }
304 appInfo.nativeLibraryPath = MallocCString(externalNativeLibraryPath);
305 appInfo.multiAppMode.multiAppModeType = static_cast<int32_t>(cAppInfo.multiAppMode.multiAppModeType);
306 appInfo.multiAppMode.count = cAppInfo.multiAppMode.maxCount;
307 appInfo.appIndex = cAppInfo.appIndex;
308 appInfo.installSource = MallocCString(cAppInfo.installSource);
309 appInfo.releaseType = MallocCString(cAppInfo.apiReleaseType);
310 return appInfo;
311 }
312
ConvertExtensionAbilityInfo(const AppExecFwk::ExtensionAbilityInfo & extensionInfos)313 RetExtensionAbilityInfo ConvertExtensionAbilityInfo(const AppExecFwk::ExtensionAbilityInfo& extensionInfos)
314 {
315 RetExtensionAbilityInfo exInfo;
316 exInfo.bundleName = MallocCString(extensionInfos.bundleName);
317 exInfo.moduleName = MallocCString(extensionInfos.moduleName);
318 exInfo.name = MallocCString(extensionInfos.name);
319 exInfo.labelId = extensionInfos.labelId;
320 exInfo.descriptionId = extensionInfos.descriptionId;
321 exInfo.iconId = extensionInfos.iconId;
322 exInfo.exported = extensionInfos.visible;
323 exInfo.extensionAbilityType = static_cast<int32_t>(extensionInfos.type);
324 exInfo.permissions = ConvertArrString(extensionInfos.permissions);
325 exInfo.applicationInfo = ConvertApplicationInfo(extensionInfos.applicationInfo);
326 exInfo.metadata = ConvertArrMetadata(extensionInfos.metadata);
327 exInfo.enabled = extensionInfos.enabled;
328 exInfo.readPermission = MallocCString(extensionInfos.readPermission);
329 exInfo.writePermission = MallocCString(extensionInfos.writePermission);
330 exInfo.extensionAbilityTypeName = MallocCString(extensionInfos.extensionTypeName);
331 return exInfo;
332 }
333
ConvertExtensionAbilityInfoV2(const AppExecFwk::ExtensionAbilityInfo & extensionInfos)334 RetExtensionAbilityInfoV2 ConvertExtensionAbilityInfoV2(const AppExecFwk::ExtensionAbilityInfo& extensionInfos)
335 {
336 RetExtensionAbilityInfoV2 exInfo;
337 exInfo.bundleName = MallocCString(extensionInfos.bundleName);
338 exInfo.moduleName = MallocCString(extensionInfos.moduleName);
339 exInfo.name = MallocCString(extensionInfos.name);
340 exInfo.labelId = extensionInfos.labelId;
341 exInfo.descriptionId = extensionInfos.descriptionId;
342 exInfo.iconId = extensionInfos.iconId;
343 exInfo.exported = extensionInfos.visible;
344 exInfo.extensionAbilityType = static_cast<int32_t>(extensionInfos.type);
345 exInfo.permissions = ConvertArrString(extensionInfos.permissions);
346 exInfo.applicationInfo = ConvertApplicationInfoV2(extensionInfos.applicationInfo);
347 exInfo.metadata = ConvertArrMetadata(extensionInfos.metadata);
348 exInfo.enabled = extensionInfos.enabled;
349 exInfo.readPermission = MallocCString(extensionInfos.readPermission);
350 exInfo.writePermission = MallocCString(extensionInfos.writePermission);
351 exInfo.extensionAbilityTypeName = MallocCString(extensionInfos.extensionTypeName);
352 exInfo.skills = ConvertSkills(extensionInfos.skills);
353 exInfo.appIndex = extensionInfos.appIndex;
354 return exInfo;
355 }
356
ConvertArrExtensionAbilityInfo(const std::vector<AppExecFwk::ExtensionAbilityInfo> & extensionInfos)357 CArrRetExtensionAbilityInfo ConvertArrExtensionAbilityInfo(
358 const std::vector<AppExecFwk::ExtensionAbilityInfo>& extensionInfos)
359 {
360 CArrRetExtensionAbilityInfo exAbInfo;
361 exAbInfo.size = static_cast<int64_t>(extensionInfos.size());
362 exAbInfo.head = nullptr;
363 if (exAbInfo.size > 0) {
364 RetExtensionAbilityInfo *retValue = reinterpret_cast<RetExtensionAbilityInfo *>
365 (malloc(sizeof(RetExtensionAbilityInfo) * exAbInfo.size));
366 if (retValue != nullptr) {
367 for (int32_t i = 0; i < exAbInfo.size; i++) {
368 retValue[i] = ConvertExtensionAbilityInfo(extensionInfos[i]);
369 }
370 exAbInfo.head = retValue;
371 } else {
372 APP_LOGE("ConvertArrExtensionAbilityInfo malloc failed");
373 return exAbInfo;
374 }
375 }
376 return exAbInfo;
377 }
378
ConvertArrExtensionAbilityInfoV2(const std::vector<AppExecFwk::ExtensionAbilityInfo> & extensionInfos)379 CArrRetExtensionAbilityInfoV2 ConvertArrExtensionAbilityInfoV2(
380 const std::vector<AppExecFwk::ExtensionAbilityInfo>& extensionInfos)
381 {
382 CArrRetExtensionAbilityInfoV2 exAbInfo;
383 exAbInfo.size = static_cast<int64_t>(extensionInfos.size());
384 exAbInfo.head = nullptr;
385 if (exAbInfo.size > 0) {
386 RetExtensionAbilityInfoV2 *retValue = reinterpret_cast<RetExtensionAbilityInfoV2 *>
387 (malloc(sizeof(RetExtensionAbilityInfoV2) * exAbInfo.size));
388 if (retValue != nullptr) {
389 for (int32_t i = 0; i < exAbInfo.size; i++) {
390 retValue[i] = ConvertExtensionAbilityInfoV2(extensionInfos[i]);
391 }
392 exAbInfo.head = retValue;
393 } else {
394 APP_LOGE("ConvertArrExtensionAbilityInfo malloc failed");
395 return exAbInfo;
396 }
397 }
398 return exAbInfo;
399 }
400
ConvertSignatureInfo(const AppExecFwk::SignatureInfo & cSignatureInfo)401 RetSignatureInfo ConvertSignatureInfo(const AppExecFwk::SignatureInfo& cSignatureInfo)
402 {
403 RetSignatureInfo signatureInfo;
404 signatureInfo.appId = MallocCString(cSignatureInfo.appId);
405 signatureInfo.fingerprint = MallocCString(cSignatureInfo.fingerprint);
406 signatureInfo.appIdentifier = MallocCString(cSignatureInfo.appIdentifier);
407 return signatureInfo;
408 }
409
ConvertAbilityInfo(const AppExecFwk::AbilityInfo & cAbilityInfos)410 RetAbilityInfo ConvertAbilityInfo(const AppExecFwk::AbilityInfo& cAbilityInfos)
411 {
412 RetAbilityInfo abInfo;
413 abInfo.bundleName = MallocCString(cAbilityInfos.bundleName);
414 abInfo.moduleName = MallocCString(cAbilityInfos.moduleName);
415 abInfo.name = MallocCString(cAbilityInfos.name);
416 abInfo.label = MallocCString(cAbilityInfos.label);
417 abInfo.labelId = cAbilityInfos.labelId;
418 abInfo.description = MallocCString(cAbilityInfos.description);
419 abInfo.descriptionId = cAbilityInfos.descriptionId;
420 abInfo.icon = MallocCString(cAbilityInfos.iconPath);
421 abInfo.iconId = cAbilityInfos.iconId;
422 abInfo.process = MallocCString(cAbilityInfos.process);
423 abInfo.exported = cAbilityInfos.visible;
424 abInfo.orientation = static_cast<int32_t>(cAbilityInfos.orientation);
425 abInfo.launchType = static_cast<int32_t>(cAbilityInfos.launchMode);
426 abInfo.permissions = ConvertArrString(cAbilityInfos.permissions);
427 abInfo.deviceTypes = ConvertArrString(cAbilityInfos.deviceTypes);
428 abInfo.applicationInfo = ConvertApplicationInfo(cAbilityInfos.applicationInfo);
429 abInfo.metadata = ConvertArrMetadata(cAbilityInfos.metadata);
430 abInfo.enabled = cAbilityInfos.enabled;
431
432 abInfo.supportWindowModes.size = static_cast<int64_t>(cAbilityInfos.windowModes.size());
433 abInfo.supportWindowModes.head = nullptr;
434 if (abInfo.supportWindowModes.size > 0) {
435 int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * abInfo.supportWindowModes.size));
436 if (retValue != nullptr) {
437 for (int32_t i = 0; i < abInfo.supportWindowModes.size; i++) {
438 retValue[i] = static_cast<int32_t>(cAbilityInfos.windowModes[i]);
439 }
440 abInfo.supportWindowModes.head = retValue;
441 } else {
442 APP_LOGE("ConvertAbilityInfo malloc failed");
443 return abInfo;
444 }
445 }
446
447 abInfo.windowSize.maxWindowRatio = cAbilityInfos.maxWindowRatio;
448 abInfo.windowSize.minWindowRatio = cAbilityInfos.minWindowRatio;
449 abInfo.windowSize.maxWindowWidth = cAbilityInfos.maxWindowWidth;
450 abInfo.windowSize.minWindowWidth = cAbilityInfos.minWindowWidth;
451 abInfo.windowSize.maxWindowHeight = cAbilityInfos.maxWindowHeight;
452 abInfo.windowSize.minWindowHeight = cAbilityInfos.minWindowHeight;
453 return abInfo;
454 }
455
ConvertAbilityInfoV2(const AppExecFwk::AbilityInfo & cAbilityInfos)456 RetAbilityInfoV2 ConvertAbilityInfoV2(const AppExecFwk::AbilityInfo& cAbilityInfos)
457 {
458 RetAbilityInfoV2 abInfo;
459 abInfo.bundleName = MallocCString(cAbilityInfos.bundleName);
460 abInfo.moduleName = MallocCString(cAbilityInfos.moduleName);
461 abInfo.name = MallocCString(cAbilityInfos.name);
462 abInfo.label = MallocCString(cAbilityInfos.label);
463 abInfo.labelId = cAbilityInfos.labelId;
464 abInfo.description = MallocCString(cAbilityInfos.description);
465 abInfo.descriptionId = cAbilityInfos.descriptionId;
466 abInfo.icon = MallocCString(cAbilityInfos.iconPath);
467 abInfo.iconId = cAbilityInfos.iconId;
468 abInfo.process = MallocCString(cAbilityInfos.process);
469 abInfo.exported = cAbilityInfos.visible;
470 abInfo.orientation = static_cast<int32_t>(cAbilityInfos.orientation);
471 abInfo.launchType = static_cast<int32_t>(cAbilityInfos.launchMode);
472 abInfo.permissions = ConvertArrString(cAbilityInfos.permissions);
473 abInfo.deviceTypes = ConvertArrString(cAbilityInfos.deviceTypes);
474 abInfo.applicationInfo = ConvertApplicationInfoV2(cAbilityInfos.applicationInfo);
475 abInfo.metadata = ConvertArrMetadata(cAbilityInfos.metadata);
476 abInfo.enabled = cAbilityInfos.enabled;
477
478 abInfo.supportWindowModes.size = static_cast<int64_t>(cAbilityInfos.windowModes.size());
479 abInfo.supportWindowModes.head = nullptr;
480 if (abInfo.supportWindowModes.size > 0) {
481 int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * abInfo.supportWindowModes.size));
482 if (retValue != nullptr) {
483 for (int32_t i = 0; i < abInfo.supportWindowModes.size; i++) {
484 retValue[i] = static_cast<int32_t>(cAbilityInfos.windowModes[i]);
485 }
486 abInfo.supportWindowModes.head = retValue;
487 } else {
488 APP_LOGE("ConvertAbilityInfo malloc failed");
489 return abInfo;
490 }
491 }
492
493 abInfo.windowSize.maxWindowRatio = cAbilityInfos.maxWindowRatio;
494 abInfo.windowSize.minWindowRatio = cAbilityInfos.minWindowRatio;
495 abInfo.windowSize.maxWindowWidth = cAbilityInfos.maxWindowWidth;
496 abInfo.windowSize.minWindowWidth = cAbilityInfos.minWindowWidth;
497 abInfo.windowSize.maxWindowHeight = cAbilityInfos.maxWindowHeight;
498 abInfo.windowSize.minWindowHeight = cAbilityInfos.minWindowHeight;
499
500 abInfo.excludeFromDock = cAbilityInfos.excludeFromDock;
501 abInfo.skills = ConvertSkills(cAbilityInfos.skills);
502 return abInfo;
503 }
504
ConvertArrAbilityInfo(const std::vector<AppExecFwk::AbilityInfo> & abilityInfos)505 CArrRetAbilityInfo ConvertArrAbilityInfo(const std::vector<AppExecFwk::AbilityInfo>& abilityInfos)
506 {
507 CArrRetAbilityInfo abInfo;
508 abInfo.size = static_cast<int64_t>(abilityInfos.size());
509 abInfo.head = nullptr;
510 if (abInfo.size > 0) {
511 RetAbilityInfo *retValue = reinterpret_cast<RetAbilityInfo *>(malloc(sizeof(RetAbilityInfo) * abInfo.size));
512 if (retValue != nullptr) {
513 for (int32_t i = 0; i < abInfo.size; i++) {
514 retValue[i] = ConvertAbilityInfo(abilityInfos[i]);
515 }
516 abInfo.head = retValue;
517 } else {
518 APP_LOGE("ConvertArrAbilityInfo malloc failed");
519 return abInfo;
520 }
521 }
522 return abInfo;
523 }
524
ConvertArrAbilityInfoV2(const std::vector<AppExecFwk::AbilityInfo> & abilityInfos)525 CArrRetAbilityInfoV2 ConvertArrAbilityInfoV2(const std::vector<AppExecFwk::AbilityInfo>& abilityInfos)
526 {
527 CArrRetAbilityInfoV2 abInfo;
528 abInfo.size = static_cast<int64_t>(abilityInfos.size());
529 abInfo.head = nullptr;
530 if (abInfo.size > 0) {
531 RetAbilityInfoV2 *retValue =
532 reinterpret_cast<RetAbilityInfoV2 *>(malloc(sizeof(RetAbilityInfoV2) * abInfo.size));
533 if (retValue != nullptr) {
534 for (int32_t i = 0; i < abInfo.size; i++) {
535 retValue[i] = ConvertAbilityInfoV2(abilityInfos[i]);
536 }
537 abInfo.head = retValue;
538 } else {
539 APP_LOGE("ConvertArrAbilityInfo malloc failed");
540 return abInfo;
541 }
542 }
543 return abInfo;
544 }
545
ConvertPreloadItem(const std::vector<AppExecFwk::PreloadItem> & preloads)546 CArrRetPreloadItem ConvertPreloadItem(const std::vector<AppExecFwk::PreloadItem>& preloads)
547 {
548 CArrRetPreloadItem pLoad;
549 pLoad.size = static_cast<int64_t>(preloads.size());
550 pLoad.head = nullptr;
551 if (pLoad.size > 0) {
552 RetPreloadItem *retValue = reinterpret_cast<RetPreloadItem *>(malloc(sizeof(RetPreloadItem) * pLoad.size));
553 if (retValue != nullptr) {
554 for (int32_t i = 0; i < pLoad.size; i++) {
555 retValue[i].moduleName = MallocCString(preloads[i].moduleName);
556 }
557 pLoad.head = retValue;
558 } else {
559 APP_LOGE("ConvertPreloadItem malloc failed");
560 return pLoad;
561 }
562 }
563 return pLoad;
564 }
565
ConvertDependency(const std::vector<AppExecFwk::Dependency> & dependencies)566 CArrRetDependency ConvertDependency(const std::vector<AppExecFwk::Dependency>& dependencies)
567 {
568 CArrRetDependency dep;
569 dep.size = static_cast<int64_t>(dependencies.size());
570 dep.head = nullptr;
571 if (dep.size > 0) {
572 RetDependency *retValue = reinterpret_cast<RetDependency *>(malloc(sizeof(RetDependency) * dep.size));
573 if (retValue != nullptr) {
574 for (int32_t i = 0; i < dep.size; i++) {
575 retValue[i].bundleName = MallocCString(dependencies[i].bundleName);
576 retValue[i].moduleName = MallocCString(dependencies[i].moduleName);
577 retValue[i].versionCode = dependencies[i].versionCode;
578 }
579 dep.head = retValue;
580 } else {
581 APP_LOGE("ConvertDependency malloc failed");
582 return dep;
583 }
584 }
585 return dep;
586 }
587
ConvertArrDataItem(const std::map<std::string,std::string> & data)588 CArrDataItem ConvertArrDataItem(const std::map<std::string, std::string>& data)
589 {
590 CArrDataItem dataItems;
591 dataItems.size = static_cast<int64_t>(data.size());
592 dataItems.head = nullptr;
593
594 if (dataItems.size == 0) {
595 return dataItems;
596 }
597 CDataItem *retValue = reinterpret_cast<CDataItem *>
598 (malloc(sizeof(CDataItem) * dataItems.size));
599 if (retValue != nullptr) {
600 int i = 0;
601 for (auto it = data.begin(); it != data.end(); ++it) {
602 retValue[i].key = MallocCString(it->first);
603 retValue[i].value = MallocCString(it->second);
604 i = i + 1;
605 }
606 dataItems.head = retValue;
607 } else {
608 APP_LOGE("ConvertArrDataItem malloc failed");
609 return dataItems;
610 }
611 return dataItems;
612 }
613
ConvertRouterItem(const AppExecFwk::RouterItem & router)614 CRouterItem ConvertRouterItem(const AppExecFwk::RouterItem& router)
615 {
616 CRouterItem routerItem;
617 routerItem.name = MallocCString(router.name);
618 routerItem.pageSourceFile = MallocCString(router.pageSourceFile);
619 routerItem.buildFunction = MallocCString(router.buildFunction);
620 routerItem.data = ConvertArrDataItem(router.data);
621 routerItem.customData = MallocCString(router.customData);
622 return routerItem;
623 }
624
ConvertRouterMap(const std::vector<AppExecFwk::RouterItem> & routerArray)625 CArrRouterItem ConvertRouterMap(const std::vector<AppExecFwk::RouterItem>& routerArray)
626 {
627 CArrRouterItem routerMap;
628 routerMap.size = static_cast<int64_t>(routerArray.size());
629 routerMap.head = nullptr;
630
631 if (routerMap.size == 0) {
632 return routerMap;
633 }
634
635 CRouterItem *retValue = reinterpret_cast<CRouterItem *>
636 (malloc(sizeof(CRouterItem) * routerMap.size));
637 if (retValue != nullptr) {
638 for (int32_t i = 0; i < routerMap.size; i++) {
639 retValue[i] = ConvertRouterItem(routerArray[i]);
640 }
641 routerMap.head = retValue;
642 } else {
643 APP_LOGE("ConvertRouterMap malloc failed");
644 return routerMap;
645 }
646 return routerMap;
647 }
648
ConvertHapModuleInfo(const AppExecFwk::HapModuleInfo & hapModuleInfo)649 RetHapModuleInfo ConvertHapModuleInfo(const AppExecFwk::HapModuleInfo& hapModuleInfo)
650 {
651 RetHapModuleInfo hapInfo;
652 hapInfo.name = MallocCString(hapModuleInfo.name);
653 hapInfo.icon = MallocCString(hapModuleInfo.iconPath);
654 hapInfo.iconId = hapModuleInfo.iconId;
655 hapInfo.label = MallocCString(hapModuleInfo.label);
656 hapInfo.labelId = hapModuleInfo.labelId;
657 hapInfo.description = MallocCString(hapModuleInfo.description);
658 hapInfo.descriptionId = hapModuleInfo.descriptionId;
659 hapInfo.mainElementName = MallocCString(hapModuleInfo.mainElementName);
660
661 hapInfo.abilitiesInfo = ConvertArrAbilityInfo(hapModuleInfo.abilityInfos);
662
663 hapInfo.extensionAbilitiesInfo = ConvertArrExtensionAbilityInfo(hapModuleInfo.extensionInfos);
664
665 hapInfo.metadata = ConvertArrMetadata(hapModuleInfo.metadata);
666
667 hapInfo.deviceTypes = ConvertArrString(hapModuleInfo.deviceTypes);
668
669 hapInfo.installationFree = hapModuleInfo.installationFree;
670 hapInfo.hashValue = MallocCString(hapModuleInfo.hashValue);
671 hapInfo.moduleType = static_cast<int32_t>(hapModuleInfo.moduleType);
672
673 hapInfo.preloads = ConvertPreloadItem(hapModuleInfo.preloads);
674
675 hapInfo.dependencies = ConvertDependency(hapModuleInfo.dependencies);
676
677 if (!hapModuleInfo.fileContextMenu.empty()) {
678 hapInfo.fileContextMenuConfig = MallocCString(hapModuleInfo.fileContextMenu);
679 } else {
680 hapInfo.fileContextMenuConfig = MallocCString("");
681 }
682 return hapInfo;
683 }
684
ConvertHapModuleInfoV2(const AppExecFwk::HapModuleInfo & hapModuleInfo)685 RetHapModuleInfoV2 ConvertHapModuleInfoV2(const AppExecFwk::HapModuleInfo& hapModuleInfo)
686 {
687 RetHapModuleInfoV2 hapInfo;
688 hapInfo.name = MallocCString(hapModuleInfo.name);
689 hapInfo.icon = MallocCString(hapModuleInfo.iconPath);
690 hapInfo.iconId = hapModuleInfo.iconId;
691 hapInfo.label = MallocCString(hapModuleInfo.label);
692 hapInfo.labelId = hapModuleInfo.labelId;
693 hapInfo.description = MallocCString(hapModuleInfo.description);
694 hapInfo.descriptionId = hapModuleInfo.descriptionId;
695 hapInfo.mainElementName = MallocCString(hapModuleInfo.mainElementName);
696
697 hapInfo.abilitiesInfo = ConvertArrAbilityInfoV2(hapModuleInfo.abilityInfos);
698
699 hapInfo.extensionAbilitiesInfo = ConvertArrExtensionAbilityInfoV2(hapModuleInfo.extensionInfos);
700
701 hapInfo.metadata = ConvertArrMetadata(hapModuleInfo.metadata);
702
703 hapInfo.deviceTypes = ConvertArrString(hapModuleInfo.deviceTypes);
704
705 hapInfo.installationFree = hapModuleInfo.installationFree;
706 hapInfo.hashValue = MallocCString(hapModuleInfo.hashValue);
707 hapInfo.moduleType = static_cast<int32_t>(hapModuleInfo.moduleType);
708
709 hapInfo.preloads = ConvertPreloadItem(hapModuleInfo.preloads);
710
711 hapInfo.dependencies = ConvertDependency(hapModuleInfo.dependencies);
712
713 if (!hapModuleInfo.fileContextMenu.empty()) {
714 hapInfo.fileContextMenuConfig = MallocCString(hapModuleInfo.fileContextMenu);
715 } else {
716 hapInfo.fileContextMenuConfig = MallocCString("");
717 }
718 hapInfo.routerMap = ConvertRouterMap(hapModuleInfo.routerArray);
719
720 size_t result = hapModuleInfo.hapPath.find(PATH_PREFIX);
721 if (result != std::string::npos) {
722 size_t pos = hapModuleInfo.hapPath.find_last_of('/');
723 std::string codePath = CODE_PATH_PREFIX;
724 if (pos != std::string::npos && pos != hapModuleInfo.hapPath.size() - 1) {
725 codePath += hapModuleInfo.hapPath.substr(pos + 1);
726 }
727 hapInfo.codePath = MallocCString(codePath);
728 } else {
729 hapInfo.codePath = MallocCString(hapModuleInfo.hapPath);
730 }
731
732 std::string externalNativeLibraryPath = "";
733 if (!hapModuleInfo.nativeLibraryPath.empty() && !hapModuleInfo.moduleName.empty()) {
734 externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + hapModuleInfo.nativeLibraryPath;
735 }
736 hapInfo.nativeLibraryPath = MallocCString(externalNativeLibraryPath);
737 return hapInfo;
738 }
739
740 extern "C" {
741 #define EXPORT __attribute__((visibility("default")))
OHOS_ConvertAbilityInfoV2(void * param)742 EXPORT RetAbilityInfoV2 OHOS_ConvertAbilityInfoV2(void* param)
743 {
744 RetAbilityInfoV2 retInfo = {};
745 auto abilityInfo = reinterpret_cast<AppExecFwk::AbilityInfo*>(param);
746 if (abilityInfo == nullptr) {
747 return retInfo;
748 }
749 return ConvertAbilityInfoV2(*abilityInfo);
750 }
751
OHOS_ConvertHapInfoV2(void * param)752 EXPORT RetHapModuleInfoV2 OHOS_ConvertHapInfoV2(void* param)
753 {
754 RetHapModuleInfoV2 retInfo = {};
755 auto hapModuleInfo = reinterpret_cast<AppExecFwk::HapModuleInfo*>(param);
756 if (hapModuleInfo == nullptr) {
757 return retInfo;
758 }
759 return ConvertHapModuleInfoV2(*hapModuleInfo);
760 }
761 }
762
ConvertArrHapInfo(const std::vector<AppExecFwk::HapModuleInfo> & hapModuleInfos)763 CArrHapInfo ConvertArrHapInfo(const std::vector<AppExecFwk::HapModuleInfo>& hapModuleInfos)
764 {
765 CArrHapInfo hapInfos;
766 hapInfos.size = static_cast<int64_t>(hapModuleInfos.size());
767 hapInfos.head = nullptr;
768 if (hapInfos.size == 0) {
769 return hapInfos;
770 }
771 RetHapModuleInfo *retValue = reinterpret_cast<RetHapModuleInfo *>(malloc(sizeof(RetHapModuleInfo) * hapInfos.size));
772 if (retValue == nullptr) {
773 APP_LOGE("ConvertArrHapInfo malloc failed");
774 return hapInfos;
775 }
776 for (int32_t i = 0; i < hapInfos.size; i++) {
777 retValue[i] = ConvertHapModuleInfo(hapModuleInfos[i]);
778 }
779 hapInfos.head = retValue;
780 return hapInfos;
781 }
782
ConvertArrHapInfoV2(const std::vector<AppExecFwk::HapModuleInfo> & hapModuleInfos)783 CArrHapInfoV2 ConvertArrHapInfoV2(const std::vector<AppExecFwk::HapModuleInfo>& hapModuleInfos)
784 {
785 CArrHapInfoV2 hapInfos;
786 hapInfos.size = static_cast<int64_t>(hapModuleInfos.size());
787 hapInfos.head = nullptr;
788 if (hapInfos.size == 0) {
789 return hapInfos;
790 }
791 RetHapModuleInfoV2 *retValue =
792 reinterpret_cast<RetHapModuleInfoV2 *>(malloc(sizeof(RetHapModuleInfoV2) * hapInfos.size));
793 if (retValue == nullptr) {
794 APP_LOGE("ConvertArrHapInfo malloc failed");
795 return hapInfos;
796 }
797 for (int32_t i = 0; i < hapInfos.size; i++) {
798 retValue[i] = ConvertHapModuleInfoV2(hapModuleInfos[i]);
799 }
800 hapInfos.head = retValue;
801 return hapInfos;
802 }
803
ConvertArrReqPerDetail(const std::vector<AppExecFwk::RequestPermission> & reqPermissionDetails)804 CArrReqPerDetail ConvertArrReqPerDetail(const std::vector<AppExecFwk::RequestPermission>& reqPermissionDetails)
805 {
806 CArrReqPerDetail perDetail;
807 perDetail.size = static_cast<int64_t>(reqPermissionDetails.size());
808 perDetail.head = nullptr;
809 if (perDetail.size > 0) {
810 RetReqPermissionDetail *retValue = reinterpret_cast<RetReqPermissionDetail *>
811 (malloc(sizeof(RetReqPermissionDetail) * perDetail.size));
812 if (retValue != nullptr) {
813 for (int32_t i = 0; i < perDetail.size; i++) {
814 retValue[i] = ConvertRequestPermission(reqPermissionDetails[i]);
815 }
816 perDetail.head = retValue;
817 } else {
818 APP_LOGE("ConvertArrReqPerDetail malloc failed");
819 return perDetail;
820 }
821 }
822 return perDetail;
823 }
824
InitSignInfo()825 RetSignatureInfo InitSignInfo()
826 {
827 RetSignatureInfo signatureInfo = {nullptr, nullptr, nullptr};
828 return signatureInfo;
829 }
830
InitApplicationInfo()831 RetApplicationInfo InitApplicationInfo()
832 {
833 RetApplicationInfo appInfo;
834 appInfo.name = nullptr;
835 appInfo.description = nullptr;
836 appInfo.descriptionId = 0;
837 appInfo.enabled = true;
838 appInfo.label = nullptr;
839 appInfo.labelId = 0;
840 appInfo.icon = nullptr;
841 appInfo.iconId = 0;
842 appInfo.process = nullptr;
843 appInfo.permissions = {nullptr, 0};
844 appInfo.codePath = nullptr;
845 appInfo.metadataArray = {nullptr, 0};
846 appInfo.removable = true;
847 appInfo.accessTokenId = 0;
848 appInfo.uid = -1;
849 appInfo.iconResource = {nullptr, nullptr, 0};
850 appInfo.labelResource = {nullptr, nullptr, 0};
851 appInfo.descriptionResource = {nullptr, nullptr, 0};
852 appInfo.appDistributionType = MallocCString("none");
853 appInfo.appProvisionType = MallocCString("release");
854 appInfo.systemApp = false;
855 appInfo.bundleType = 0;
856 appInfo.debug = false;
857 appInfo.dataUnclearable = false;
858 appInfo.cloudFileSyncEnabled = false;
859 return appInfo;
860 }
861
InitApplicationInfoV2()862 RetApplicationInfoV2 InitApplicationInfoV2()
863 {
864 RetApplicationInfoV2 appInfo;
865 appInfo.name = nullptr;
866 appInfo.description = nullptr;
867 appInfo.descriptionId = 0;
868 appInfo.enabled = true;
869 appInfo.label = nullptr;
870 appInfo.labelId = 0;
871 appInfo.icon = nullptr;
872 appInfo.iconId = 0;
873 appInfo.process = nullptr;
874 appInfo.permissions = {nullptr, 0};
875 appInfo.codePath = nullptr;
876 appInfo.metadataArray = {nullptr, 0};
877 appInfo.removable = true;
878 appInfo.accessTokenId = 0;
879 appInfo.uid = -1;
880 appInfo.iconResource = {nullptr, nullptr, 0};
881 appInfo.labelResource = {nullptr, nullptr, 0};
882 appInfo.descriptionResource = {nullptr, nullptr, 0};
883 appInfo.appDistributionType = MallocCString("none");
884 appInfo.appProvisionType = MallocCString("release");
885 appInfo.systemApp = false;
886 appInfo.bundleType = 0;
887 appInfo.debug = false;
888 appInfo.dataUnclearable = false;
889 appInfo.cloudFileSyncEnabled = false;
890 appInfo.nativeLibraryPath = MallocCString("");
891 appInfo.multiAppMode.multiAppModeType = static_cast<uint8_t>(0);
892 appInfo.multiAppMode.count = 0;
893 appInfo.appIndex = 0;
894 appInfo.installSource = MallocCString("");
895 appInfo.releaseType = MallocCString("");
896 return appInfo;
897 }
898
ConvertBundleInfo(const AppExecFwk::BundleInfo & cBundleInfo,int32_t flags)899 RetBundleInfo ConvertBundleInfo(const AppExecFwk::BundleInfo& cBundleInfo, int32_t flags)
900 {
901 RetBundleInfo bundleInfo;
902 bundleInfo.name = MallocCString(cBundleInfo.name);
903 bundleInfo.vendor = MallocCString(cBundleInfo.vendor);
904 bundleInfo.versionCode = cBundleInfo.versionCode;
905 bundleInfo.versionName = MallocCString(cBundleInfo.versionName);
906 bundleInfo.minCompatibleVersionCode = cBundleInfo.minCompatibleVersionCode;
907 bundleInfo.targetVersion = cBundleInfo.targetVersion;
908 if ((static_cast<uint32_t>(flags) &
909 static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
910 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
911 bundleInfo.appInfo = ConvertApplicationInfo(cBundleInfo.applicationInfo);
912 } else {
913 bundleInfo.appInfo = InitApplicationInfo();
914 }
915
916 bundleInfo.hapInfo = ConvertArrHapInfo(cBundleInfo.hapModuleInfos);
917 bundleInfo.perDetail = ConvertArrReqPerDetail(cBundleInfo.reqPermissionDetails);
918
919 bundleInfo.state.size = static_cast<int64_t>(cBundleInfo.reqPermissionStates.size());
920 bundleInfo.state.head = nullptr;
921 if (bundleInfo.state.size > 0) {
922 int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * bundleInfo.state.size));
923 if (retValue != nullptr) {
924 for (int32_t i = 0; i < bundleInfo.state.size; i++) {
925 retValue[i] = static_cast<int32_t>(cBundleInfo.reqPermissionStates[i]);
926 }
927 bundleInfo.state.head = retValue;
928 } else {
929 APP_LOGE("ConvertBundleInfo malloc failed");
930 return bundleInfo;
931 }
932 }
933
934 if ((static_cast<uint32_t>(flags) &
935 static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
936 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
937 bundleInfo.signInfo = ConvertSignatureInfo(cBundleInfo.signatureInfo);
938 } else {
939 bundleInfo.signInfo = InitSignInfo();
940 }
941 bundleInfo.installTime = cBundleInfo.installTime;
942 bundleInfo.updateTime = cBundleInfo.updateTime;
943 bundleInfo.uid = cBundleInfo.uid;
944 return bundleInfo;
945 }
946
ConvertBundleInfoV2(const AppExecFwk::BundleInfo & cBundleInfo,int32_t flags)947 RetBundleInfoV2 ConvertBundleInfoV2(const AppExecFwk::BundleInfo& cBundleInfo, int32_t flags)
948 {
949 RetBundleInfoV2 bundleInfo;
950 bundleInfo.name = MallocCString(cBundleInfo.name);
951 bundleInfo.vendor = MallocCString(cBundleInfo.vendor);
952 bundleInfo.versionCode = cBundleInfo.versionCode;
953 bundleInfo.versionName = MallocCString(cBundleInfo.versionName);
954 bundleInfo.minCompatibleVersionCode = cBundleInfo.minCompatibleVersionCode;
955 bundleInfo.targetVersion = cBundleInfo.targetVersion;
956 if ((static_cast<uint32_t>(flags) &
957 static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
958 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
959 bundleInfo.appInfo = ConvertApplicationInfoV2(cBundleInfo.applicationInfo);
960 } else {
961 bundleInfo.appInfo = InitApplicationInfoV2();
962 }
963
964 bundleInfo.hapInfo = ConvertArrHapInfoV2(cBundleInfo.hapModuleInfos);
965 bundleInfo.perDetail = ConvertArrReqPerDetail(cBundleInfo.reqPermissionDetails);
966
967 bundleInfo.state.size = static_cast<int64_t>(cBundleInfo.reqPermissionStates.size());
968 bundleInfo.state.head = nullptr;
969 if (bundleInfo.state.size > 0) {
970 int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * bundleInfo.state.size));
971 if (retValue != nullptr) {
972 for (int32_t i = 0; i < bundleInfo.state.size; i++) {
973 retValue[i] = static_cast<int32_t>(cBundleInfo.reqPermissionStates[i]);
974 }
975 bundleInfo.state.head = retValue;
976 } else {
977 APP_LOGE("ConvertBundleInfo malloc failed");
978 return bundleInfo;
979 }
980 }
981
982 if ((static_cast<uint32_t>(flags) &
983 static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
984 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
985 bundleInfo.signInfo = ConvertSignatureInfo(cBundleInfo.signatureInfo);
986 } else {
987 bundleInfo.signInfo = InitSignInfo();
988 }
989 bundleInfo.installTime = cBundleInfo.installTime;
990 bundleInfo.updateTime = cBundleInfo.updateTime;
991 bundleInfo.uid = cBundleInfo.uid;
992 bundleInfo.routerMap = ConvertRouterMap(cBundleInfo.routerArray);
993 bundleInfo.appIndex = cBundleInfo.appIndex;
994 return bundleInfo;
995 }
996
997 } // Convert
998 } // BundleManager
999 } // CJSystemapi
1000 } // OHOS