diff --git a/interfaces/kits/cj/src/bundle_manager_convert.cpp b/interfaces/kits/cj/src/bundle_manager_convert.cpp
index 62c47493161e6fc45e3627de87c27463a995aa1c..ed0e245ca4e7e7e97281bf41d4e42ca0db6f5fb0 100644
--- a/interfaces/kits/cj/src/bundle_manager_convert.cpp
+++ b/interfaces/kits/cj/src/bundle_manager_convert.cpp
@@ -253,6 +253,43 @@ RetApplicationInfo ConvertApplicationInfo(const AppExecFwk::ApplicationInfo& cAp
     appInfo.labelResource = ConvertResource(cAppInfo.labelResource);
     appInfo.descriptionResource = ConvertResource(cAppInfo.descriptionResource);
 
+    appInfo.appDistributionType = MallocCString(cAppInfo.appDistributionType);
+    appInfo.appProvisionType = MallocCString(cAppInfo.appProvisionType);
+    appInfo.systemApp = cAppInfo.isSystemApp;
+    appInfo.bundleType = static_cast<int32_t>(cAppInfo.bundleType);
+    appInfo.debug = cAppInfo.debug;
+    appInfo.dataUnclearable = !cAppInfo.userDataClearable;
+    appInfo.cloudFileSyncEnabled = cAppInfo.cloudFileSyncEnabled;
+    return appInfo;
+}
+
+RetApplicationInfoV2 ConvertApplicationInfoV2(const AppExecFwk::ApplicationInfo& cAppInfo)
+{
+    RetApplicationInfoV2 appInfo;
+    appInfo.name = MallocCString(cAppInfo.name);
+    appInfo.description = MallocCString(cAppInfo.description);
+    appInfo.descriptionId = cAppInfo.descriptionId;
+    appInfo.enabled = cAppInfo.enabled;
+    appInfo.label = MallocCString(cAppInfo.label);
+    appInfo.labelId = cAppInfo.labelId;
+    appInfo.icon = MallocCString(cAppInfo.iconPath);
+    appInfo.iconId = cAppInfo.iconId;
+    appInfo.process = MallocCString(cAppInfo.process);
+
+    appInfo.permissions = ConvertArrString(cAppInfo.permissions);
+
+    appInfo.codePath = MallocCString(cAppInfo.codePath);
+
+    appInfo.metadataArray = ConvertArrMoMeta(cAppInfo.metadata);
+
+    appInfo.removable = cAppInfo.removable;
+    appInfo.accessTokenId = cAppInfo.accessTokenId;
+    appInfo.uid = cAppInfo.uid;
+
+    appInfo.iconResource = ConvertResource(cAppInfo.iconResource);
+    appInfo.labelResource = ConvertResource(cAppInfo.labelResource);
+    appInfo.descriptionResource = ConvertResource(cAppInfo.descriptionResource);
+
     appInfo.appDistributionType = MallocCString(cAppInfo.appDistributionType);
     appInfo.appProvisionType = MallocCString(cAppInfo.appProvisionType);
     appInfo.systemApp = cAppInfo.isSystemApp;
@@ -291,6 +328,27 @@ RetExtensionAbilityInfo ConvertExtensionAbilityInfo(const AppExecFwk::ExtensionA
     exInfo.readPermission = MallocCString(extensionInfos.readPermission);
     exInfo.writePermission = MallocCString(extensionInfos.writePermission);
     exInfo.extensionAbilityTypeName = MallocCString(extensionInfos.extensionTypeName);
+    return exInfo;
+}
+
+RetExtensionAbilityInfoV2 ConvertExtensionAbilityInfoV2(const AppExecFwk::ExtensionAbilityInfo& extensionInfos)
+{
+    RetExtensionAbilityInfoV2 exInfo;
+    exInfo.bundleName = MallocCString(extensionInfos.bundleName);
+    exInfo.moduleName = MallocCString(extensionInfos.moduleName);
+    exInfo.name = MallocCString(extensionInfos.name);
+    exInfo.labelId = extensionInfos.labelId;
+    exInfo.descriptionId = extensionInfos.descriptionId;
+    exInfo.iconId = extensionInfos.iconId;
+    exInfo.exported = extensionInfos.visible;
+    exInfo.extensionAbilityType = static_cast<int32_t>(extensionInfos.type);
+    exInfo.permissions = ConvertArrString(extensionInfos.permissions);
+    exInfo.applicationInfo = ConvertApplicationInfoV2(extensionInfos.applicationInfo);
+    exInfo.metadata = ConvertArrMetadata(extensionInfos.metadata);
+    exInfo.enabled = extensionInfos.enabled;
+    exInfo.readPermission = MallocCString(extensionInfos.readPermission);
+    exInfo.writePermission = MallocCString(extensionInfos.writePermission);
+    exInfo.extensionAbilityTypeName = MallocCString(extensionInfos.extensionTypeName);
     exInfo.skills = ConvertSkills(extensionInfos.skills);
     exInfo.appIndex = extensionInfos.appIndex;
     return exInfo;
@@ -318,6 +376,28 @@ CArrRetExtensionAbilityInfo ConvertArrExtensionAbilityInfo(
     return exAbInfo;
 }
 
+CArrRetExtensionAbilityInfoV2 ConvertArrExtensionAbilityInfoV2(
+    const std::vector<AppExecFwk::ExtensionAbilityInfo>& extensionInfos)
+{
+    CArrRetExtensionAbilityInfoV2 exAbInfo;
+    exAbInfo.size = static_cast<int64_t>(extensionInfos.size());
+    exAbInfo.head = nullptr;
+    if (exAbInfo.size > 0) {
+        RetExtensionAbilityInfoV2 *retValue = reinterpret_cast<RetExtensionAbilityInfoV2 *>
+        (malloc(sizeof(RetExtensionAbilityInfoV2) * exAbInfo.size));
+        if (retValue != nullptr) {
+            for (int32_t i = 0; i < exAbInfo.size; i++) {
+                retValue[i] = ConvertExtensionAbilityInfoV2(extensionInfos[i]);
+            }
+            exAbInfo.head = retValue;
+        } else {
+            APP_LOGE("ConvertArrExtensionAbilityInfo malloc failed");
+            return exAbInfo;
+        }
+    }
+    return exAbInfo;
+}
+
 RetSignatureInfo ConvertSignatureInfo(const AppExecFwk::SignatureInfo& cSignatureInfo)
 {
     RetSignatureInfo signatureInfo;
@@ -364,6 +444,52 @@ RetAbilityInfo ConvertAbilityInfo(const AppExecFwk::AbilityInfo& cAbilityInfos)
         }
     }
 
+    abInfo.windowSize.maxWindowRatio = cAbilityInfos.maxWindowRatio;
+    abInfo.windowSize.minWindowRatio = cAbilityInfos.minWindowRatio;
+    abInfo.windowSize.maxWindowWidth = cAbilityInfos.maxWindowWidth;
+    abInfo.windowSize.minWindowWidth = cAbilityInfos.minWindowWidth;
+    abInfo.windowSize.maxWindowHeight = cAbilityInfos.maxWindowHeight;
+    abInfo.windowSize.minWindowHeight = cAbilityInfos.minWindowHeight;
+    return abInfo;
+}
+
+RetAbilityInfoV2 ConvertAbilityInfoV2(const AppExecFwk::AbilityInfo& cAbilityInfos)
+{
+    RetAbilityInfoV2 abInfo;
+    abInfo.bundleName = MallocCString(cAbilityInfos.bundleName);
+    abInfo.moduleName = MallocCString(cAbilityInfos.moduleName);
+    abInfo.name = MallocCString(cAbilityInfos.name);
+    abInfo.label = MallocCString(cAbilityInfos.label);
+    abInfo.labelId = cAbilityInfos.labelId;
+    abInfo.description = MallocCString(cAbilityInfos.description);
+    abInfo.descriptionId = cAbilityInfos.descriptionId;
+    abInfo.icon = MallocCString(cAbilityInfos.iconPath);
+    abInfo.iconId = cAbilityInfos.iconId;
+    abInfo.process = MallocCString(cAbilityInfos.process);
+    abInfo.exported = cAbilityInfos.visible;
+    abInfo.orientation = static_cast<int32_t>(cAbilityInfos.orientation);
+    abInfo.launchType = static_cast<int32_t>(cAbilityInfos.launchMode);
+    abInfo.permissions = ConvertArrString(cAbilityInfos.permissions);
+    abInfo.deviceTypes = ConvertArrString(cAbilityInfos.deviceTypes);
+    abInfo.applicationInfo = ConvertApplicationInfoV2(cAbilityInfos.applicationInfo);
+    abInfo.metadata = ConvertArrMetadata(cAbilityInfos.metadata);
+    abInfo.enabled = cAbilityInfos.enabled;
+
+    abInfo.supportWindowModes.size = static_cast<int64_t>(cAbilityInfos.windowModes.size());
+    abInfo.supportWindowModes.head = nullptr;
+    if (abInfo.supportWindowModes.size > 0) {
+        int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * abInfo.supportWindowModes.size));
+        if (retValue != nullptr) {
+            for (int32_t i = 0; i < abInfo.supportWindowModes.size; i++) {
+                retValue[i] = static_cast<int32_t>(cAbilityInfos.windowModes[i]);
+            }
+            abInfo.supportWindowModes.head = retValue;
+        } else {
+            APP_LOGE("ConvertAbilityInfo malloc failed");
+            return abInfo;
+        }
+    }
+
     abInfo.windowSize.maxWindowRatio = cAbilityInfos.maxWindowRatio;
     abInfo.windowSize.minWindowRatio = cAbilityInfos.minWindowRatio;
     abInfo.windowSize.maxWindowWidth = cAbilityInfos.maxWindowWidth;
@@ -396,6 +522,27 @@ CArrRetAbilityInfo ConvertArrAbilityInfo(const std::vector<AppExecFwk::AbilityIn
     return abInfo;
 }
 
+CArrRetAbilityInfoV2 ConvertArrAbilityInfoV2(const std::vector<AppExecFwk::AbilityInfo>& abilityInfos)
+{
+    CArrRetAbilityInfoV2 abInfo;
+    abInfo.size = static_cast<int64_t>(abilityInfos.size());
+    abInfo.head = nullptr;
+    if (abInfo.size > 0) {
+        RetAbilityInfoV2 *retValue =
+            reinterpret_cast<RetAbilityInfoV2 *>(malloc(sizeof(RetAbilityInfoV2) * abInfo.size));
+        if (retValue != nullptr) {
+            for (int32_t i = 0; i < abInfo.size; i++) {
+                retValue[i] = ConvertAbilityInfoV2(abilityInfos[i]);
+            }
+            abInfo.head = retValue;
+        } else {
+            APP_LOGE("ConvertArrAbilityInfo malloc failed");
+            return abInfo;
+        }
+    }
+    return abInfo;
+}
+
 CArrRetPreloadItem ConvertPreloadItem(const std::vector<AppExecFwk::PreloadItem>& preloads)
 {
     CArrRetPreloadItem pLoad;
@@ -527,6 +674,42 @@ RetHapModuleInfo ConvertHapModuleInfo(const AppExecFwk::HapModuleInfo& hapModule
 
     hapInfo.dependencies = ConvertDependency(hapModuleInfo.dependencies);
 
+    if (!hapModuleInfo.fileContextMenu.empty()) {
+        hapInfo.fileContextMenuConfig = MallocCString(hapModuleInfo.fileContextMenu);
+    } else {
+        hapInfo.fileContextMenuConfig = MallocCString("");
+    }
+    return hapInfo;
+}
+
+RetHapModuleInfoV2 ConvertHapModuleInfoV2(const AppExecFwk::HapModuleInfo& hapModuleInfo)
+{
+    RetHapModuleInfoV2 hapInfo;
+    hapInfo.name = MallocCString(hapModuleInfo.name);
+    hapInfo.icon = MallocCString(hapModuleInfo.iconPath);
+    hapInfo.iconId = hapModuleInfo.iconId;
+    hapInfo.label = MallocCString(hapModuleInfo.label);
+    hapInfo.labelId = hapModuleInfo.labelId;
+    hapInfo.description = MallocCString(hapModuleInfo.description);
+    hapInfo.descriptionId = hapModuleInfo.descriptionId;
+    hapInfo.mainElementName = MallocCString(hapModuleInfo.mainElementName);
+
+    hapInfo.abilitiesInfo = ConvertArrAbilityInfoV2(hapModuleInfo.abilityInfos);
+
+    hapInfo.extensionAbilitiesInfo = ConvertArrExtensionAbilityInfoV2(hapModuleInfo.extensionInfos);
+
+    hapInfo.metadata = ConvertArrMetadata(hapModuleInfo.metadata);
+
+    hapInfo.deviceTypes = ConvertArrString(hapModuleInfo.deviceTypes);
+
+    hapInfo.installationFree = hapModuleInfo.installationFree;
+    hapInfo.hashValue = MallocCString(hapModuleInfo.hashValue);
+    hapInfo.moduleType = static_cast<int32_t>(hapModuleInfo.moduleType);
+
+    hapInfo.preloads = ConvertPreloadItem(hapModuleInfo.preloads);
+
+    hapInfo.dependencies = ConvertDependency(hapModuleInfo.dependencies);
+
     if (!hapModuleInfo.fileContextMenu.empty()) {
         hapInfo.fileContextMenuConfig = MallocCString(hapModuleInfo.fileContextMenu);
     } else {
@@ -556,24 +739,24 @@ RetHapModuleInfo ConvertHapModuleInfo(const AppExecFwk::HapModuleInfo& hapModule
 
 extern "C" {
 #define EXPORT __attribute__((visibility("default")))
-EXPORT RetAbilityInfo OHOS_ConvertAbilityInfo(void* param)
+EXPORT RetAbilityInfoV2 OHOS_ConvertAbilityInfoV2(void* param)
 {
-    RetAbilityInfo retInfo;
+    RetAbilityInfoV2 retInfo;
     auto abilityInfo = reinterpret_cast<AppExecFwk::AbilityInfo*>(param);
     if (abilityInfo == nullptr) {
         return retInfo;
     }
-    return ConvertAbilityInfo(*abilityInfo);
+    return ConvertAbilityInfoV2(*abilityInfo);
 }
 
-EXPORT RetHapModuleInfo OHOS_ConvertHapInfo(void* param)
+EXPORT RetHapModuleInfoV2 OHOS_ConvertHapInfoV2(void* param)
 {
-    RetHapModuleInfo retInfo;
+    RetHapModuleInfoV2 retInfo;
     auto hapModuleInfo = reinterpret_cast<AppExecFwk::HapModuleInfo*>(param);
     if (hapModuleInfo == nullptr) {
         return retInfo;
     }
-    return ConvertHapModuleInfo(*hapModuleInfo);
+    return ConvertHapModuleInfoV2(*hapModuleInfo);
 }
 }
 
@@ -597,6 +780,27 @@ CArrHapInfo ConvertArrHapInfo(const std::vector<AppExecFwk::HapModuleInfo>& hapM
     return hapInfos;
 }
 
+CArrHapInfoV2 ConvertArrHapInfoV2(const std::vector<AppExecFwk::HapModuleInfo>& hapModuleInfos)
+{
+    CArrHapInfoV2 hapInfos;
+    hapInfos.size = static_cast<int64_t>(hapModuleInfos.size());
+    hapInfos.head = nullptr;
+    if (hapInfos.size == 0) {
+        return hapInfos;
+    }
+    RetHapModuleInfoV2 *retValue =
+        reinterpret_cast<RetHapModuleInfoV2 *>(malloc(sizeof(RetHapModuleInfoV2) * hapInfos.size));
+    if (retValue == nullptr) {
+        APP_LOGE("ConvertArrHapInfo malloc failed");
+        return hapInfos;
+    }
+    for (int32_t i = 0; i < hapInfos.size; i++) {
+        retValue[i] = ConvertHapModuleInfoV2(hapModuleInfos[i]);
+    }
+    hapInfos.head = retValue;
+    return hapInfos;
+}
+
 CArrReqPerDetail ConvertArrReqPerDetail(const std::vector<AppExecFwk::RequestPermission>& reqPermissionDetails)
 {
     CArrReqPerDetail perDetail;
@@ -652,6 +856,37 @@ RetApplicationInfo InitApplicationInfo()
     appInfo.debug = false;
     appInfo.dataUnclearable = false;
     appInfo.cloudFileSyncEnabled = false;
+    return appInfo;
+}
+
+RetApplicationInfoV2 InitApplicationInfoV2()
+{
+    RetApplicationInfoV2 appInfo;
+    appInfo.name = nullptr;
+    appInfo.description = nullptr;
+    appInfo.descriptionId = 0;
+    appInfo.enabled = true;
+    appInfo.label = nullptr;
+    appInfo.labelId = 0;
+    appInfo.icon = nullptr;
+    appInfo.iconId = 0;
+    appInfo.process = nullptr;
+    appInfo.permissions = {nullptr, 0};
+    appInfo.codePath = nullptr;
+    appInfo.metadataArray = {nullptr, 0};
+    appInfo.removable = true;
+    appInfo.accessTokenId = 0;
+    appInfo.uid = -1;
+    appInfo.iconResource = {nullptr, nullptr, 0};
+    appInfo.labelResource = {nullptr, nullptr, 0};
+    appInfo.descriptionResource = {nullptr, nullptr, 0};
+    appInfo.appDistributionType = MallocCString("none");
+    appInfo.appProvisionType = MallocCString("release");
+    appInfo.systemApp = false;
+    appInfo.bundleType = 0;
+    appInfo.debug = false;
+    appInfo.dataUnclearable = false;
+    appInfo.cloudFileSyncEnabled = false;
     appInfo.nativeLibraryPath = MallocCString("");
     appInfo.multiAppMode.multiAppModeType = static_cast<uint8_t>(0);
     appInfo.multiAppMode.count = 0;
@@ -696,6 +931,54 @@ RetBundleInfo ConvertBundleInfo(const AppExecFwk::BundleInfo& cBundleInfo, int32
         }
     }
 
+    if ((static_cast<uint32_t>(flags) &
+        static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
+        == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
+        bundleInfo.signInfo = ConvertSignatureInfo(cBundleInfo.signatureInfo);
+    } else {
+        bundleInfo.signInfo = InitSignInfo();
+    }
+    bundleInfo.installTime = cBundleInfo.installTime;
+    bundleInfo.updateTime = cBundleInfo.updateTime;
+    bundleInfo.uid = cBundleInfo.uid;
+    return bundleInfo;
+}
+
+RetBundleInfoV2 ConvertBundleInfoV2(const AppExecFwk::BundleInfo& cBundleInfo, int32_t flags)
+{
+    RetBundleInfoV2 bundleInfo;
+    bundleInfo.name = MallocCString(cBundleInfo.name);
+    bundleInfo.vendor = MallocCString(cBundleInfo.vendor);
+    bundleInfo.versionCode = cBundleInfo.versionCode;
+    bundleInfo.versionName = MallocCString(cBundleInfo.versionName);
+    bundleInfo.minCompatibleVersionCode = cBundleInfo.minCompatibleVersionCode;
+    bundleInfo.targetVersion = cBundleInfo.targetVersion;
+    if ((static_cast<uint32_t>(flags) &
+        static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
+        == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
+        bundleInfo.appInfo = ConvertApplicationInfoV2(cBundleInfo.applicationInfo);
+    } else {
+        bundleInfo.appInfo = InitApplicationInfoV2();
+    }
+
+    bundleInfo.hapInfo = ConvertArrHapInfoV2(cBundleInfo.hapModuleInfos);
+    bundleInfo.perDetail = ConvertArrReqPerDetail(cBundleInfo.reqPermissionDetails);
+
+    bundleInfo.state.size = static_cast<int64_t>(cBundleInfo.reqPermissionStates.size());
+    bundleInfo.state.head = nullptr;
+    if (bundleInfo.state.size > 0) {
+        int32_t *retValue = static_cast<int32_t *>(malloc(sizeof(int32_t) * bundleInfo.state.size));
+        if (retValue != nullptr) {
+            for (int32_t i = 0; i < bundleInfo.state.size; i++) {
+                retValue[i] = static_cast<int32_t>(cBundleInfo.reqPermissionStates[i]);
+            }
+            bundleInfo.state.head = retValue;
+        } else {
+            APP_LOGE("ConvertBundleInfo malloc failed");
+            return bundleInfo;
+        }
+    }
+
     if ((static_cast<uint32_t>(flags) &
         static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
         == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
diff --git a/interfaces/kits/cj/src/bundle_manager_convert.h b/interfaces/kits/cj/src/bundle_manager_convert.h
index 0b572ce3154218abc02350c4737e241c74d8da3f..688eac1da6a6c2e0a98c15b180a15608a5dab4fb 100644
--- a/interfaces/kits/cj/src/bundle_manager_convert.h
+++ b/interfaces/kits/cj/src/bundle_manager_convert.h
@@ -34,6 +34,13 @@ namespace Convert {
     RetAbilityInfo ConvertAbilityInfo(const AppExecFwk::AbilityInfo& cAbilityInfos);
     RetHapModuleInfo ConvertHapModuleInfo(const AppExecFwk::HapModuleInfo& hapModuleInfo);
     RetBundleInfo ConvertBundleInfo(const AppExecFwk::BundleInfo& cBundleInfo, int32_t flags);
+    RetApplicationInfoV2 ConvertApplicationInfoV2(const AppExecFwk::ApplicationInfo& cAppInfo);
+    RetExtensionAbilityInfoV2 ConvertExtensionAbilityInfoV2(const AppExecFwk::ExtensionAbilityInfo& extensionInfos);
+    CArrRetExtensionAbilityInfoV2 ConvertArrExtensionAbilityInfoV2(
+        const std::vector<AppExecFwk::ExtensionAbilityInfo>& extensionInfos);
+    RetAbilityInfoV2 ConvertAbilityInfoV2(const AppExecFwk::AbilityInfo& cAbilityInfos);
+    RetHapModuleInfoV2 ConvertHapModuleInfoV2(const AppExecFwk::HapModuleInfo& hapModuleInfo);
+    RetBundleInfoV2 ConvertBundleInfoV2(const AppExecFwk::BundleInfo& cBundleInfo, int32_t flags);
 } // Convert
  
 } // BundleManager
diff --git a/interfaces/kits/cj/src/bundle_manager_ffi.cpp b/interfaces/kits/cj/src/bundle_manager_ffi.cpp
index ee02f1f6602e1273f85615b67bf6e1d0c3999db4..0e21382b0f3a6f6672ebd2622e129f9020fffe2e 100644
--- a/interfaces/kits/cj/src/bundle_manager_ffi.cpp
+++ b/interfaces/kits/cj/src/bundle_manager_ffi.cpp
@@ -90,7 +90,16 @@ extern "C" {
         APP_LOGI("BundleManager::FfiOHOSGetBundleInfoForSelf success");
         return cjInfo;
     }
- 
+
+    RetBundleInfoV2 FfiOHOSGetBundleInfoForSelfV2(int32_t bundleFlags)
+    {
+        APP_LOGI("BundleManager::FfiOHOSGetBundleInfoForSelf");
+        AppExecFwk::BundleInfo bundleInfo = BundleManagerImpl::GetBundleInfoForSelf(bundleFlags);
+        RetBundleInfoV2 cjInfo = ConvertBundleInfoV2(bundleInfo, bundleFlags);
+        APP_LOGI("BundleManager::FfiOHOSGetBundleInfoForSelf success");
+        return cjInfo;
+    }
+
     int32_t FfiOHOSVerifyAbc(CArrString cAbcPaths, bool deleteOriginalFiles)
     {
         APP_LOGI("BundleManager::FfiOHOSVerifyAbc");
diff --git a/interfaces/kits/cj/src/bundle_manager_ffi.h b/interfaces/kits/cj/src/bundle_manager_ffi.h
index b4089dd6b55bf7cf14c1680e61a33662a39208e0..296e86fac147911bf6c3024b3866444598708961 100755
--- a/interfaces/kits/cj/src/bundle_manager_ffi.h
+++ b/interfaces/kits/cj/src/bundle_manager_ffi.h
@@ -27,6 +27,7 @@ namespace BundleManager {
 extern "C" {
     FFI_EXPORT int32_t FfiOHOSGetCallingUid();
     FFI_EXPORT RetBundleInfo FfiOHOSGetBundleInfoForSelf(int32_t bundleFlags);
+    FFI_EXPORT RetBundleInfoV2 FfiOHOSGetBundleInfoForSelfV2(int32_t bundleFlags);
     FFI_EXPORT int32_t FfiOHOSVerifyAbc(CArrString cAbcPaths, bool deleteOriginalFiles);
     FFI_EXPORT RetCArrString FfiGetProfileByExtensionAbility(
         char* moduleName, char* extensionAbilityName, char* metadataName);
diff --git a/interfaces/kits/cj/src/bundle_manager_utils.h b/interfaces/kits/cj/src/bundle_manager_utils.h
index 55c196ead5d658efff7fe655c72a01dfb4eea74c..d2bdc7dfdf8e37a7f24384c7ef47b4caae2b7122 100644
--- a/interfaces/kits/cj/src/bundle_manager_utils.h
+++ b/interfaces/kits/cj/src/bundle_manager_utils.h
@@ -85,11 +85,6 @@ namespace BundleManager {
         bool debug;
         bool dataUnclearable;
         bool cloudFileSyncEnabled;
-        char* nativeLibraryPath;
-        MultiAppMode multiAppMode;
-        int32_t appIndex;
-        char* installSource;
-        char* releaseType;
     };
 
     struct CArrInt32 {
@@ -157,9 +152,6 @@ namespace BundleManager {
         bool enabled;
         CArrInt32 supportWindowModes;
         RetWindowSize windowSize;
-        bool excludeFromDock;
-        RetCArrSkill skills;
-        int32_t appIndex;
     };
 
     struct CArrRetAbilityInfo {
@@ -183,8 +175,6 @@ namespace BundleManager {
         char* readPermission;
         char* writePermission;
         char* extensionAbilityTypeName;
-        RetCArrSkill skills;
-        int32_t appIndex;
     };
 
     struct CArrRetExtensionAbilityInfo {
@@ -253,9 +243,6 @@ namespace BundleManager {
         CArrRetPreloadItem preloads;
         CArrRetDependency dependencies;
         char* fileContextMenuConfig;
-        CArrRouterItem routerMap;
-        char* codePath;
-        char* nativeLibraryPath;
     };
 
     struct CArrHapInfo {
@@ -324,8 +311,6 @@ namespace BundleManager {
         int64_t installTime;
         int64_t updateTime;
         int32_t uid;
-        CArrRouterItem routerMap;
-        int32_t appIndex;
     };
 
     enum BundleFlag {
@@ -357,6 +342,144 @@ namespace BundleManager {
         GET_BUNDLE_INFO_WITH_ROUTER_MAP = 0x00000200,
         GET_BUNDLE_INFO_WITH_SKILL = 0x00000800,
     };
+
+
+    struct RetApplicationInfoV2 {
+        char* name;
+        char* description;
+        uint32_t descriptionId;
+        bool enabled;
+        char* label;
+        uint32_t labelId;
+        char* icon;
+        uint32_t iconId;
+        char* process;
+        CArrString permissions;
+        char* codePath;
+        CArrMoMeta metadataArray;
+        bool removable;
+        uint32_t accessTokenId;
+        int32_t uid;
+        CResource iconResource;
+        CResource labelResource;
+        CResource descriptionResource;
+        char* appDistributionType;
+        char* appProvisionType;
+        bool systemApp;
+        int32_t bundleType;
+        bool debug;
+        bool dataUnclearable;
+        bool cloudFileSyncEnabled;
+        char* nativeLibraryPath;
+        MultiAppMode multiAppMode;
+        int32_t appIndex;
+        char* installSource;
+        char* releaseType;
+    };
+
+    struct RetAbilityInfoV2 {
+        char* bundleName;
+        char* moduleName;
+        char* name;
+        char* label;
+        uint32_t labelId;
+        char* description;
+        uint32_t descriptionId;
+        char* icon;
+        uint32_t iconId;
+        char* process;
+        bool exported;
+        int32_t orientation;
+        int32_t launchType;
+        CArrString permissions;
+        CArrString deviceTypes;
+        RetApplicationInfoV2 applicationInfo;
+        CArrMetadata metadata;
+        bool enabled;
+        CArrInt32 supportWindowModes;
+        RetWindowSize windowSize;
+        bool excludeFromDock;
+        RetCArrSkill skills;
+        int32_t appIndex;
+    };
+
+    struct CArrRetAbilityInfoV2 {
+        RetAbilityInfoV2* head;
+        int64_t size;
+    };
+
+    struct RetExtensionAbilityInfoV2 {
+        char* bundleName;
+        char* moduleName;
+        char* name;
+        uint32_t labelId;
+        uint32_t descriptionId;
+        uint32_t iconId;
+        bool exported;
+        int32_t extensionAbilityType;
+        CArrString permissions;
+        RetApplicationInfoV2 applicationInfo;
+        CArrMetadata metadata;
+        bool enabled;
+        char* readPermission;
+        char* writePermission;
+        char* extensionAbilityTypeName;
+        RetCArrSkill skills;
+        int32_t appIndex;
+    };
+
+    struct CArrRetExtensionAbilityInfoV2 {
+        RetExtensionAbilityInfoV2* head;
+        int64_t size;
+    };
+
+    struct RetHapModuleInfoV2 {
+        char* name;
+        char* icon;
+        uint32_t iconId;
+        char* label;
+        uint32_t labelId;
+        char* description;
+        uint32_t descriptionId;
+        char* mainElementName;
+        CArrRetAbilityInfoV2 abilitiesInfo;
+        CArrRetExtensionAbilityInfoV2 extensionAbilitiesInfo;
+        CArrMetadata metadata;
+        CArrString deviceTypes;
+        bool installationFree;
+        char* hashValue;
+        int32_t moduleType;
+        CArrRetPreloadItem preloads;
+        CArrRetDependency dependencies;
+        char* fileContextMenuConfig;
+        CArrRouterItem routerMap;
+        char* codePath;
+        char* nativeLibraryPath;
+    };
+
+    struct CArrHapInfoV2 {
+        RetHapModuleInfoV2* head;
+        int64_t size;
+    };
+
+    struct RetBundleInfoV2 {
+        char* name;
+        char* vendor;
+        uint32_t versionCode;
+        char* versionName;
+        uint32_t minCompatibleVersionCode;
+        uint32_t targetVersion;
+        RetApplicationInfoV2 appInfo;
+        CArrHapInfoV2 hapInfo;
+        CArrReqPerDetail perDetail;
+        CArrInt32 state;
+        RetSignatureInfo signInfo;
+        int64_t installTime;
+        int64_t updateTime;
+        int32_t uid;
+        CArrRouterItem routerMap;
+        int32_t appIndex;
+    };
 } // BundleManager
 } // CJSystemapi
 } // OHOS
diff --git a/services/bundlemgr/test/unittest/bms_bundle_manager_convert_test/bms_bundle_manager_convert_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_manager_convert_test/bms_bundle_manager_convert_test.cpp
index 946ea9c1290c89e42925bbffa87bff332ee490cc..5f98af169a3e88557cdba0d15cb5d48101dc9a47 100644
--- a/services/bundlemgr/test/unittest/bms_bundle_manager_convert_test/bms_bundle_manager_convert_test.cpp
+++ b/services/bundlemgr/test/unittest/bms_bundle_manager_convert_test/bms_bundle_manager_convert_test.cpp
@@ -44,8 +44,8 @@ HWTEST_F(BundleManagerConvertTest, ConvertApplicationInfo_0001, Function | Small
 {
     ApplicationInfo cAppInfo;
     cAppInfo.appIndex = 1;
-    CJSystemapi::BundleManager::RetApplicationInfo retApplicationInfoTest =
-        CJSystemapi::BundleManager::Convert::ConvertApplicationInfo(cAppInfo);
+    CJSystemapi::BundleManager::RetApplicationInfoV2 retApplicationInfoTest =
+        CJSystemapi::BundleManager::Convert::ConvertApplicationInfoV2(cAppInfo);
     EXPECT_EQ(retApplicationInfoTest.appIndex, 1);
 }