diff --git a/frameworks/bundle_lite/include/bundle_callback_utils.h b/frameworks/bundle_lite/include/bundle_callback_utils.h
index ec1031d71392948b4ce0245c7e88fc8be5afe0a8..6053d5828cea12768f8ec66005aaa2e15a4035c6 100755
--- a/frameworks/bundle_lite/include/bundle_callback_utils.h
+++ b/frameworks/bundle_lite/include/bundle_callback_utils.h
@@ -72,4 +72,9 @@ struct ResultOfGetBundleSize {
     uint8_t resultCode;
     uint32_t bundleSize;
 };
+
+struct BasicInfo {
+    char *metaDataKey;
+    int32_t flags;
+};
 #endif // OHOS_BUNDLE_CALLBACK_UTILS_H
\ No newline at end of file
diff --git a/frameworks/bundle_lite/src/bundle_manager.cpp b/frameworks/bundle_lite/src/bundle_manager.cpp
index 6822a7dbafe558e3f5fe8a341f59f76174c51a12..50be38de30d6d614ea14ba4ef519e43747c7e0e7 100644
--- a/frameworks/bundle_lite/src/bundle_manager.cpp
+++ b/frameworks/bundle_lite/src/bundle_manager.cpp
@@ -92,6 +92,7 @@ static uint8_t DeserializeInnerAbilityInfo(IOwner owner, IpcIo *reply)
 
 static uint8_t DeserializeInnerBundleInfo(IOwner owner, IpcIo *reply)
 {
+    HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfo start");
     if ((reply == nullptr) || (owner == nullptr)) {
         return OHOS_FAILURE;
     }
@@ -112,14 +113,17 @@ static uint8_t DeserializeInnerBundleInfo(IOwner owner, IpcIo *reply)
     info->bundleInfo = OHOS::ConvertUtils::ConvertStringToBundleInfo(jsonStr, len);
     if (info->bundleInfo == nullptr) {
         info->resultCode = ERR_APPEXECFWK_DESERIALIZATION_FAILED;
+        HILOG_ERROR(HILOG_MODULE_APP, "ConvertStringToBundleInfo failed");
         return ERR_APPEXECFWK_DESERIALIZATION_FAILED;
     }
     info->resultCode = resultCode;
+    HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfo finished");
     return resultCode;
 }
 
 static uint8_t DeserializeInnerBundleInfos(IOwner owner, IpcIo *reply)
 {
+    HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfos start");
     if ((reply == nullptr) || (owner == nullptr)) {
         return OHOS_FAILURE;
     }
@@ -145,6 +149,7 @@ static uint8_t DeserializeInnerBundleInfos(IOwner owner, IpcIo *reply)
     }
 
     info->resultCode = resultCode;
+    HILOG_DEBUG(HILOG_MODULE_APP, "DeserializeInnerBundleInfos finished");
     return resultCode;
 }
 
@@ -276,6 +281,22 @@ static int Notify(IOwner owner, int code, IpcIo *reply)
         case GET_BUNDLE_INFOS_BY_METADATA: {
             return DeserializeInnerBundleInfos(owner, reply);
         }
+        case GET_BUNDLE_INFO_LENGTH: {
+            ResultOfGetBundleInfos *resultOfGetBundleInfos = reinterpret_cast<ResultOfGetBundleInfos *>(owner);
+            uint8_t errCode;
+            ReadUint8(reply, &errCode);
+            if (errCode != ERR_OK) {
+                HILOG_INFO(HILOG_MODULE_APP, "BundleManager get bundleInfos length failed due to %{public}d", errCode);
+                resultOfGetBundleInfos->resultCode = errCode;
+                return errCode;
+            }
+            ReadInt32(reply, &(resultOfGetBundleInfos->length));
+            HILOG_INFO(HILOG_MODULE_APP, "BundleManager bundleInfo len is: %{public}d", resultOfGetBundleInfos->length);
+            break;
+        }
+        case GET_BUNDLE_INFO_BY_INDEX: {
+            return DeserializeInnerBundleInfo(owner, reply);
+        }
         case GET_BUNDLENAME_FOR_UID: {
             return DeserializeInnerBundleName(owner, reply);
         }
@@ -557,6 +578,91 @@ static uint8_t ObtainInnerBundleInfos(const int flags, BundleInfo **bundleInfos,
     return resultOfGetBundleInfos.resultCode;
 }
 
+static uint8_t ObtainBundleInfosOneByOne(BasicInfo basicInfo, int32_t len, uint8_t code, IClientProxy *bmsClient,
+    BundleInfo **bundleInfos)
+{
+    if (bmsClient == nullptr || bundleInfos == nullptr) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne failed due to nullptr parma");
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+    for (int32_t i = 0; i < len; ++i) {
+        IpcIo innerIpcIo;
+        char data[MAX_IO_SIZE];
+        IpcIoInit(&innerIpcIo, data, MAX_IO_SIZE, 0);
+        WriteInt32(&innerIpcIo, static_cast<int32_t>(code));
+        if (code == GET_BUNDLE_INFOS) {
+            WriteInt32(&innerIpcIo, basicInfo.flags);
+        }
+        if (code == GET_BUNDLE_INFOS_BY_METADATA) {
+            WriteString(&innerIpcIo, basicInfo.metaDataKey);
+        }
+        WriteInt32(&innerIpcIo, i);
+        ResultOfGetBundleInfo resultOfGetBundleInfo;
+        resultOfGetBundleInfo.bundleInfo = nullptr;
+        int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO_BY_INDEX, &innerIpcIo, &resultOfGetBundleInfo, Notify);
+        if (ret != OHOS_SUCCESS) {
+            HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfosOneByOne invoke failed: %{public}d\n", ret);
+            return ERR_APPEXECFWK_INVOKE_ERROR;
+        }
+        OHOS::BundleInfoUtils::CopyBundleInfo(basicInfo.flags, *bundleInfos + i, *(resultOfGetBundleInfo.bundleInfo));
+        ClearBundleInfo(resultOfGetBundleInfo.bundleInfo);
+        AdapterFree(resultOfGetBundleInfo.bundleInfo);
+    }
+    return OHOS_SUCCESS;
+}
+
+static uint8_t ObtainBundleInfos(BasicInfo basicInfo, BundleInfo **bundleInfos, int32_t *len,
+    uint8_t code, IpcIo *ipcIo)
+{
+    if ((bundleInfos == nullptr) || (len == nullptr) || (ipcIo == nullptr)) {
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+    if (CheckSelfPermission(static_cast<const char *>(PERMISSION_GET_BUNDLE_INFO)) != GRANTED) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos failed due to permission denied");
+        return ERR_APPEXECFWK_PERMISSION_DENIED;
+    }
+    auto bmsClient = GetBmsClient();
+    if (bmsClient == nullptr) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos failed due to nullptr bms client");
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+
+    ResultOfGetBundleInfos resultOfGetBundleInfos;
+    resultOfGetBundleInfos.length = 0;
+    resultOfGetBundleInfos.bundleInfo = nullptr;
+    int32_t ret = bmsClient->Invoke(bmsClient, GET_BUNDLE_INFO_LENGTH, ipcIo, &resultOfGetBundleInfos, Notify);
+    if (ret != OHOS_SUCCESS) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos invoke failed: %{public}d\n", ret);
+        return ERR_APPEXECFWK_INVOKE_ERROR;
+    }
+
+    if (resultOfGetBundleInfos.length == 0 || resultOfGetBundleInfos.resultCode != ERR_OK) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos fail");
+        *bundleInfos = nullptr;
+        return resultOfGetBundleInfos.resultCode;
+    }
+
+    *bundleInfos = reinterpret_cast<BundleInfo *>(AdapterMalloc(sizeof(BundleInfo) * resultOfGetBundleInfos.length));
+    if (*bundleInfos == nullptr) {
+        OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+    if (memset_s(*bundleInfos, sizeof(BundleInfo) * (resultOfGetBundleInfos.length), 0, sizeof(BundleInfo) *
+        (resultOfGetBundleInfos.length)) != EOK) {
+        AdapterFree(*bundleInfos);
+        OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
+        return ERR_APPEXECFWK_SYSTEM_INTERNAL_ERROR;
+    }
+
+    uint8_t res = ObtainBundleInfosOneByOne(basicInfo, resultOfGetBundleInfos.length, code, bmsClient, bundleInfos);
+    if (res != OHOS_SUCCESS) {
+        HILOG_WARN(HILOG_MODULE_APP, "BundleManager ObtainBundleInfos invoke failed: %{public}d\n", res);
+    }
+    *len = resultOfGetBundleInfos.length;
+    OHOS::BundleInfoUtils::FreeBundleInfos(resultOfGetBundleInfos.bundleInfo, resultOfGetBundleInfos.length);
+    return resultOfGetBundleInfos.resultCode;
+}
+
 uint8_t GetBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len)
 {
     if ((bundleInfos == nullptr) || (len == nullptr)) {
@@ -569,8 +675,12 @@ uint8_t GetBundleInfos(const int flags, BundleInfo **bundleInfos, int32_t *len)
     IpcIo ipcIo;
     char data[MAX_IO_SIZE];
     IpcIoInit(&ipcIo, data, MAX_IO_SIZE, 0);
+    WriteInt32(&ipcIo, GET_BUNDLE_INFOS);
     WriteInt32(&ipcIo, flags);
-    return ObtainInnerBundleInfos(flags, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo);
+    BasicInfo basicInfo;
+    basicInfo.flags = flags;
+    basicInfo.metaDataKey = nullptr;
+    return ObtainBundleInfos(basicInfo, bundleInfos, len, GET_BUNDLE_INFOS, &ipcIo);
 }
 
 uint32_t GetBundleSize(const char *bundleName)
diff --git a/interfaces/inner_api/bundlemgr_lite/bundle_inner_interface.h b/interfaces/inner_api/bundlemgr_lite/bundle_inner_interface.h
index c5b679ca3aa266b918796abf5c4c40141224c099..2399bf65a35f47125927307087ac2eb4c21265d7 100755
--- a/interfaces/inner_api/bundlemgr_lite/bundle_inner_interface.h
+++ b/interfaces/inner_api/bundlemgr_lite/bundle_inner_interface.h
@@ -41,6 +41,8 @@ enum BmsCmd {
     GET_BUNDLE_INFOS_BY_METADATA,
     CHECK_SYS_CAP,
     GET_BUNDLE_SIZE,
+    GET_BUNDLE_INFO_LENGTH,
+    GET_BUNDLE_INFO_BY_INDEX,
     GET_SYS_CAP,
     BMS_INNER_BEGIN,
     INSTALL = BMS_INNER_BEGIN, // bms install application
diff --git a/services/bundlemgr_lite/include/bundle_ms_feature.h b/services/bundlemgr_lite/include/bundle_ms_feature.h
index f33cfdbb3b887ca7323b696d9f5661495a50d288..4769e312988587c1d00fda6fa97e1b3de87ffc53 100755
--- a/services/bundlemgr_lite/include/bundle_ms_feature.h
+++ b/services/bundlemgr_lite/include/bundle_ms_feature.h
@@ -62,6 +62,9 @@ private:
     static uint8_t HasSystemCapability(const uint8_t funcId, IpcIo *req, IpcIo *reply);
     static uint8_t GetSystemAvailableCapabilities(const uint8_t funcId, IpcIo *req, IpcIo *reply);
     static uint8_t GetInnerBundleSize(const uint8_t funcId, IpcIo *req, IpcIo *reply);
+    static uint8_t HandleGetBundleInfosByIndex(const uint8_t funcId, IpcIo *req, IpcIo *reply);
+    static uint8_t HandleGetBundleInfosLength(const uint8_t funcId, IpcIo *req, IpcIo *reply);
+    static BundleInfo *GetInnerBundleInfos(IpcIo *req, IpcIo *reply, int32_t *length);
 
     Identity identity_;
     static BundleInvokeType BundleMsInvokeFuc[BMS_INNER_BEGIN];
diff --git a/services/bundlemgr_lite/src/bundle_ms_feature.cpp b/services/bundlemgr_lite/src/bundle_ms_feature.cpp
index b8412f6abea88a5c2c2fca8965295f2cc3a6d6fb..10f44ef9d1cbf34c946f73fa0e6064e5e817a4f4 100644
--- a/services/bundlemgr_lite/src/bundle_ms_feature.cpp
+++ b/services/bundlemgr_lite/src/bundle_ms_feature.cpp
@@ -57,6 +57,8 @@ BundleInvokeType BundleMsFeature::BundleMsInvokeFuc[BMS_INNER_BEGIN] {
     HandleGetBundleInfos,
     HasSystemCapability,
     GetInnerBundleSize,
+    HandleGetBundleInfosLength,
+    HandleGetBundleInfosByIndex,
     GetSystemAvailableCapabilities,
 };
 
@@ -562,4 +564,95 @@ uint8_t BundleMsFeature::GetBundleNameForUid(int32_t uid, char **bundleName)
     }
     return OHOS_SUCCESS;
 }
+
+BundleInfo *BundleMsFeature::GetInnerBundleInfos(IpcIo *req, IpcIo *reply, int32_t *length)
+{
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS GetInnerBundleInfos start");
+    if ((req == nullptr) || (reply == nullptr)) {
+        return nullptr;
+    }
+    BundleInfo *bundleInfos = nullptr;
+    uint8_t errorCode = 0;
+    int32_t codeFlag = -1;
+    ReadInt32(req, &codeFlag);
+    if (codeFlag == GET_BUNDLE_INFOS) {
+        int32_t flag;
+        ReadInt32(req, &flag);
+        errorCode = GetBundleInfos(flag, &bundleInfos, length);
+    } else if (codeFlag == QUERY_KEEPALIVE_BUNDLE_INFOS) {
+        errorCode = QueryKeepAliveBundleInfos(&bundleInfos, length);
+    } else if (codeFlag == GET_BUNDLE_INFOS_BY_METADATA) {
+        size_t len = 0;
+        char *metaDataKey = reinterpret_cast<char *>(ReadString(req, &len));
+        if (metaDataKey == nullptr) {
+            return nullptr;
+        }
+        errorCode = GetBundleInfosByMetaData(metaDataKey, &bundleInfos, length);
+    } else {
+        return nullptr;
+    }
+    if (errorCode != OHOS_SUCCESS) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleMS GetInnerBundleInfos failed with errorcode: %{public}d\n", errorCode);
+        BundleInfoUtils::FreeBundleInfos(bundleInfos, *length);
+        return nullptr;
+    }
+    HILOG_DEBUG(HILOG_MODULE_APP, "BundleMS GetInnerBundleInfos with length is: %{public}d\n", *length);
+    return bundleInfos;
+}
+
+uint8_t BundleMsFeature::HandleGetBundleInfosLength(const uint8_t funcId, IpcIo *req, IpcIo *reply)
+{
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosLength start");
+    if ((req == nullptr) || (reply == nullptr)) {
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+    int32_t lengthOfBundleInfo = 0;
+    BundleInfo *bundleInfos = GetInnerBundleInfos(req, reply, &lengthOfBundleInfo);
+    if (bundleInfos == nullptr) {
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleMS bundleInfos is nullptr");
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+    WriteUint8(reply, static_cast<uint8_t>(OHOS_SUCCESS));
+    WriteInt32(reply, lengthOfBundleInfo);
+    BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosLength finished");
+    return OHOS_SUCCESS;
+}
+
+uint8_t BundleMsFeature::HandleGetBundleInfosByIndex(const uint8_t funcId, IpcIo *req, IpcIo *reply)
+{
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex start");
+    if ((req == nullptr) || (reply == nullptr)) {
+        return ERR_APPEXECFWK_OBJECT_NULL;
+    }
+    int32_t lengthOfBundleInfo = 0;
+    BundleInfo *bundleInfos = GetInnerBundleInfos(req, reply, &lengthOfBundleInfo);;
+    int32_t index = 0;
+    ReadInt32(req, &index);
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS index is : %{public}d\n", index);
+    char *str = ConvertUtils::ConvertBundleInfoToString(bundleInfos + index);
+    if (str == nullptr) {
+        BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex strs is nullptr");
+        return ERR_APPEXECFWK_SERIALIZATION_FAILED;
+    }
+    HILOG_DEBUG(HILOG_MODULE_APP, "BundleMS length of str is: %{public}d\n", static_cast<int32_t>(strlen(str)));
+#ifdef __LINUX__
+    if (strlen(str) > MAX_IPC_STRING_LENGTH) {
+        BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
+        HILOG_ERROR(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex is too larger to be transformed by ipc");
+        cJSON_free(str);
+        return ERR_APPEXECFWK_SERIALIZATION_FAILED;
+    }
+#endif
+    WriteUint8(reply, static_cast<uint8_t>(OHOS_SUCCESS));
+    WriteString(reply, str);
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS bundleInfo length is %{public}d of index %{public}d",
+        static_cast<int32_t>(strlen(str)), index);
+    BundleInfoUtils::FreeBundleInfos(bundleInfos, lengthOfBundleInfo);
+
+    cJSON_free(str);
+    HILOG_INFO(HILOG_MODULE_APP, "BundleMS HandleGetBundleInfosByIndex finished");
+    return OHOS_SUCCESS;
+}
 } // namespace OHOS