Create a new automated test for Prefab basic workflows (#2715)

Adds a new ebus for prefab apis and refactored the apis Removed an empty test level Auto delete tmp level when teardown tests Add Base test level in Prefab folder Removed unused comments Checked if absolute path as an input of Create Prefab functions Changed created prefab file path to support all platfroms Added missing includes Signed-off-by: chiyteng <chiyteng@amazon.com>
2021-08-11 14:11:26 -07:00
parent c6714595b1
commit 7e5cbdab1e
15 changed files with 372 additions and 29 deletions
@@ -0,0 +1,66 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+# fmt:off
+class Tests():
+    create_new_entity =       ("Entity: 'CreateNewEntity' passed",                          "Entity: 'CreateNewEntity' failed")
+    create_prefab =           ("Prefab: 'CreatePrefab' passed",                             "Prefab: 'CreatePrefab' failed")
+    instantiate_prefab =      ("Prefab: 'InstantiatePrefab' passed",                        "Prefab: 'InstantiatePrefab' failed")
+    new_prefab_position =     ("Prefab: new prefab's position is at the expected position", "Prefab: new prefab's position is *not* at the expected position")
+# fmt:on
+
+def PrefabLevel_BasicWorkflow():
+    """
+    This test will help verify if the following functions related to Prefab work as expected: 
+    - CreatePrefab
+    - InstantiatePrefab
+    """
+
+    import os
+    import sys
+
+    from editor_python_test_tools.utils import Report
+    from editor_python_test_tools.utils import TestHelper as helper
+    import editor_python_test_tools.hydra_editor_utils as hydra
+
+    import azlmbr.bus as bus
+    import azlmbr.entity as entity
+    from azlmbr.entity import EntityId
+    import azlmbr.editor as editor
+    import azlmbr.prefab as prefab
+    from azlmbr.math import Vector3
+    import azlmbr.legacy.general as general
+
+    EXPECTED_NEW_PREFAB_POSITION = Vector3(10.00, 20.0, 30.0)
+
+    helper.init_idle()
+    helper.open_level("Prefab", "Base")
+
+# Create a new Entity at the root level
+    new_entity_id = editor.ToolsApplicationRequestBus(bus.Broadcast, 'CreateNewEntity', EntityId())
+    Report.result(Tests.create_new_entity, new_entity_id.IsValid())
+
+# Checks for prefab creation passed or not 
+    new_prefab_file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'new_prefab.prefab')
+    create_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'CreatePrefabInMemory', [new_entity_id], new_prefab_file_path)
+    Report.result(Tests.create_prefab, create_prefab_result)
+
+# Checks for prefab instantiation passed or not 
+    container_entity_id = prefab.PrefabPublicRequestBus(bus.Broadcast, 'InstantiatePrefab', new_prefab_file_path, EntityId(), EXPECTED_NEW_PREFAB_POSITION)
+    Report.result(Tests.instantiate_prefab, container_entity_id.IsValid())
+
+# Checks if the new prefab is at the correct position and if it fails, it will provide the expected postion and the actual postion of the entity in the Editor log
+    new_prefab_position = azlmbr.components.TransformBus(azlmbr.bus.Event, "GetWorldTranslation", container_entity_id)
+    is_at_position = new_prefab_position.IsClose(EXPECTED_NEW_PREFAB_POSITION)
+    Report.result(Tests.new_prefab_position, is_at_position)
+    if not is_at_position:
+        Report.info(f'Expected position: {EXPECTED_NEW_PREFAB_POSITION.ToString()}, actual position: {new_prefab_position.ToString()}')
+    
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(PrefabLevel_BasicWorkflow)
@@ -16,6 +16,7 @@ from ly_test_tools import LAUNCHERS

 sys.path.append (os.path.dirname (os.path.abspath (__file__)) + '/../automatedtesting_shared')

+import ly_test_tools.environment.file_system as file_system
 from base import TestAutomationBase

@pytest.mark.SUITE_main
@@ -29,3 +30,8 @@ class TestAutomation(TestAutomationBase):
    def test_PrefabLevel_OpensLevelWithEntities(self, request, workspace, editor, launcher_platform):
        from . import PrefabLevel_OpensLevelWithEntities as test_module
        self._run_prefab_test(request, workspace, editor, test_module)
+
+    def test_PrefabLevel_BasicWorkflow(self, request, workspace, editor, launcher_platform):       
+        from . import PrefabLevel_BasicWorkflow as test_module
+        self._run_prefab_test(request, workspace, editor, test_module)
+
@@ -0,0 +1,53 @@
+{
+    "ContainerEntity": {
+        "Id": "Entity_[1146574390643]",
+        "Name": "Level",
+        "Components": {
+            "Component_[10641544592923449938]": {
+                "$type": "EditorInspectorComponent",
+                "Id": 10641544592923449938
+            },
+            "Component_[12039882709170782873]": {
+                "$type": "EditorOnlyEntityComponent",
+                "Id": 12039882709170782873
+            },
+            "Component_[12265484671603697631]": {
+                "$type": "EditorPendingCompositionComponent",
+                "Id": 12265484671603697631
+            },
+            "Component_[14126657869720434043]": {
+                "$type": "EditorEntitySortComponent",
+                "Id": 14126657869720434043
+            },
+            "Component_[15230859088967841193]": {
+                "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent",
+                "Id": 15230859088967841193,
+                "Parent Entity": ""
+            },
+            "Component_[16239496886950819870]": {
+                "$type": "EditorDisabledCompositionComponent",
+                "Id": 16239496886950819870
+            },
+            "Component_[5688118765544765547]": {
+                "$type": "EditorEntityIconComponent",
+                "Id": 5688118765544765547
+            },
+            "Component_[6545738857812235305]": {
+                "$type": "SelectionComponent",
+                "Id": 6545738857812235305
+            },
+            "Component_[7247035804068349658]": {
+                "$type": "EditorPrefabComponent",
+                "Id": 7247035804068349658
+            },
+            "Component_[9307224322037797205]": {
+                "$type": "EditorLockComponent",
+                "Id": 9307224322037797205
+            },
+            "Component_[9562516168917670048]": {
+                "$type": "EditorVisibilityComponent",
+                "Id": 9562516168917670048
+            }
+        }
+    }
+}
@@ -600,8 +600,8 @@ namespace AzToolsFramework
         * Open 3D Engine Internal use only.
         *
         * Run a specific redo command separate from the undo/redo system.
-         * In many cases before a modifcation on an entity takes place, it is first packaged into 
-         * undo/redo commands. Running the modification's redo command separete from the undo/redo 
+         * In many cases before a modification on an entity takes place, it is first packaged into 
+         * undo/redo commands. Running the modification's redo command separate from the undo/redo 
         * system simulates its execution, and avoids some code duplication.
         */
        virtual void RunRedoSeparately(UndoSystem::URSequencePoint* redoCommand) = 0;
@@ -1781,5 +1781,4 @@ namespace AzToolsFramework
    { 
        appType.m_maskValue = AZ::ApplicationTypeQuery::Masks::Tool;
    };
-
 } // namespace AzToolsFramework
@@ -61,7 +61,7 @@ namespace AzToolsFramework
            m_prefabUndoCache.Destroy();
        }

-        PrefabOperationResult PrefabPublicHandler::CreatePrefab(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView absolutePath)
+        PrefabOperationResult PrefabPublicHandler::CreatePrefabInMemory(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath)
        {
            EntityList inputEntityList, topLevelEntities;
            AZ::EntityId commonRootEntityId;
@@ -73,8 +73,6 @@ namespace AzToolsFramework
                return findCommonRootOutcome;
            }

-            AZ_Assert(absolutePath.IsAbsolute(), "CreatePrefab requires an absolute path for saving the initial prefab file.");
-
            InstanceOptionalReference instanceToCreate;
            {
                // Initialize Undo Batch object
@@ -125,7 +123,7 @@ namespace AzToolsFramework
                    PrefabDom linkPatchesCopy;
                    linkPatchesCopy.CopyFrom(linkPatches->get(), linkPatchesCopy.GetAllocator());
                    nestedInstanceLinkPatchesMap.emplace(nestedInstance, AZStd::move(linkPatchesCopy));
-                    
+
                    RemoveLink(outInstance, commonRootEntityOwningInstance->get().GetTemplateId(), undoBatch.GetUndoBatch());

                    instancePtrs.emplace_back(AZStd::move(outInstance));
@@ -139,18 +137,20 @@ namespace AzToolsFramework
                if (!prefabEditorEntityOwnershipInterface)
                {
                    return AZ::Failure(AZStd::string("Could not create a new prefab out of the entities provided - internal error "
-                                                     "(PrefabEditorEntityOwnershipInterface unavailable)."));
+                        "(PrefabEditorEntityOwnershipInterface unavailable)."));
                }

                // Create the Prefab
+                AZ_Assert(filePath.IsAbsolute(), "CreatePrefabInMemory requires an absolute file path.");
+
                instanceToCreate = prefabEditorEntityOwnershipInterface->CreatePrefab(
-                    entities, AZStd::move(instancePtrs), m_prefabLoaderInterface->GenerateRelativePath(absolutePath),
+                    entities, AZStd::move(instancePtrs), m_prefabLoaderInterface->GenerateRelativePath(filePath),
                    commonRootEntityOwningInstance);

                if (!instanceToCreate)
                {
                    return AZ::Failure(AZStd::string("Could not create a new prefab out of the entities provided - internal error "
-                                                     "(A null instance is returned)."));
+                        "(A null instance is returned)."));
                }

                AZ::EntityId containerEntityId = instanceToCreate->get().GetContainerEntityId();
@@ -218,7 +218,7 @@ namespace AzToolsFramework
                        linkUpdate.Redo();
                    }
                });
-                
+
                // Create a link between the templates of the newly created instance and the instance it's being parented under.
                CreateLink(
                    instanceToCreate->get(), commonRootEntityOwningInstance->get().GetTemplateId(), undoBatch.GetUndoBatch(),
@@ -255,18 +255,35 @@ namespace AzToolsFramework

                // Select Container Entity
                {
-                    auto selectionUndo = aznew SelectionCommand({containerEntityId}, "Select Prefab Container Entity");
+                    auto selectionUndo = aznew SelectionCommand({ containerEntityId }, "Select Prefab Container Entity");
                    selectionUndo->SetParent(undoBatch.GetUndoBatch());
                    ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::RunRedoSeparately, selectionUndo);
                }
            }

-            // Save Template to file
-            m_prefabLoaderInterface->SaveTemplateToFile(instanceToCreate->get().GetTemplateId(), absolutePath);
-            
            return AZ::Success();
        }

+        PrefabOperationResult PrefabPublicHandler::CreatePrefabInDisk(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath)
+        {
+            auto result = CreatePrefabInMemory(entityIds, filePath);
+            if (result.IsSuccess())
+            {
+                // Save Template to file
+                auto relativePath = m_prefabLoaderInterface->GenerateRelativePath(filePath);
+                Prefab::TemplateId templateId = m_prefabSystemComponentInterface->GetTemplateIdFromFilePath(relativePath);
+                if (!m_prefabLoaderInterface->SaveTemplateToFile(templateId, filePath))
+                {
+                    AZStd::string_view filePathString(filePath);
+                    return AZ::Failure(AZStd::string::format(
+                        "Could not save the newly created prefab to file path %.*s - internal error ",
+                        AZ_STRING_ARG(filePathString)));
+                }
+            }
+            
+            return result;
+        }
+
        PrefabDom PrefabPublicHandler::ApplyContainerTransformAndGeneratePatch(AZ::EntityId containerEntityId, AZ::EntityId parentEntityId, const EntityList& childEntities)
        {
            AZ::Entity* containerEntity = GetEntityById(containerEntityId);
@@ -301,7 +318,7 @@ namespace AzToolsFramework
            return AZStd::move(patch);
        }

-        PrefabOperationResult PrefabPublicHandler::InstantiatePrefab(
+        InstantiatePrefabResult PrefabPublicHandler::InstantiatePrefab(
            AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position)
        {
            auto prefabEditorEntityOwnershipInterface = AZ::Interface<PrefabEditorEntityOwnershipInterface>::Get();
@@ -347,6 +364,7 @@ namespace AzToolsFramework
                    relativePath.Native().c_str(), instanceToParentUnder->get().GetTemplateSourcePath().Native().c_str()));
            }

+            AZ::EntityId containerEntityId;
            {
                // Initialize Undo Batch object
                ScopedUndoBatch undoBatch("Instantiate Prefab");
@@ -367,7 +385,7 @@ namespace AzToolsFramework
                    instanceToParentUnder->get(), "Update prefab instance", instanceToParentUnderDomBeforeCreate, undoBatch.GetUndoBatch());

                // Create Link with correct container patches
-                AZ::EntityId containerEntityId = instanceToCreate->get().GetContainerEntityId();
+                containerEntityId = instanceToCreate->get().GetContainerEntityId();
                AZ::Entity* containerEntity = GetEntityById(containerEntityId);
                AZ_Assert(containerEntity, "Invalid container entity detected in InstantiatePrefab.");

@@ -394,7 +412,7 @@ namespace AzToolsFramework
                    &AzToolsFramework::ToolsApplicationRequestBus::Events::ClearDirtyEntities);
            }

-            return AZ::Success();
+            return AZ::Success(containerEntityId);
        }

        PrefabOperationResult PrefabPublicHandler::FindCommonRootOwningInstance(
@@ -42,8 +42,11 @@ namespace AzToolsFramework
            void UnregisterPrefabPublicHandlerInterface();

            // PrefabPublicInterface...
-            PrefabOperationResult CreatePrefab(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView absolutePath) override;
-            PrefabOperationResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
+            PrefabOperationResult CreatePrefabInDisk(
+                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) override;
+            PrefabOperationResult CreatePrefabInMemory(
+                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) override;
+            InstantiatePrefabResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
            PrefabOperationResult SavePrefab(AZ::IO::Path filePath) override;
            PrefabEntityResult CreateEntity(AZ::EntityId parentId, const AZ::Vector3& position) override;
            
@@ -25,6 +25,7 @@ namespace AzToolsFramework
    namespace Prefab
    {
        typedef AZ::Outcome<void, AZStd::string> PrefabOperationResult;
+        typedef AZ::Outcome<AZ::EntityId, AZStd::string> InstantiatePrefabResult;
        typedef AZ::Outcome<bool, AZStd::string> PrefabRequestResult;
        typedef AZ::Outcome<AZ::EntityId, AZStd::string> PrefabEntityResult;

@@ -39,22 +40,34 @@ namespace AzToolsFramework
            AZ_RTTI(PrefabPublicInterface, "{931AAE9D-C775-4818-9070-A2DA69489CBE}");

            /**
-             * Create a prefab out of the entities provided, at the path provided.
+             * Create a prefab out of the entities provided, at the path provided, and save it in disk immediately.
             * Automatically detects descendants of entities, and discerns between entities and child instances.
             * @param entityIds The entities that should form the new prefab (along with their descendants).
             * @param filePath The absolute path for the new prefab file.
             * @return An outcome object; on failure, it comes with an error message detailing the cause of the error.
             */
-            virtual PrefabOperationResult CreatePrefab(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView absolutePath) = 0;
+            virtual PrefabOperationResult CreatePrefabInDisk(
+                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) = 0;
+
+            /**
+             * Create a prefab out of the entities provided, at the path provided, and keep it in memory.
+             * Automatically detects descendants of entities, and discerns between entities and child instances.
+             * @param entityIds The entities that should form the new prefab (along with their descendants).
+             * @param filePath The absolute path for the new prefab file.
+             * @return An outcome object; on failure, it comes with an error message detailing the cause of the error.
+             */
+            virtual PrefabOperationResult CreatePrefabInMemory(
+                const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath) = 0;

            /**
             * Instantiate a prefab from a prefab file.
             * @param filePath The path to the prefab file to instantiate.
             * @param parent The entity the prefab should be a child of in the transform hierarchy.
             * @param position The position in world space the prefab should be instantiated in.
-             * @return An outcome object; on failure, it comes with an error message detailing the cause of the error.
+             * @return An outcome object with an entityId of the new prefab's container entity;
+             *  on failure, it comes with an error message detailing the cause of the error.
             */
-            virtual PrefabOperationResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) = 0;
+            virtual InstantiatePrefabResult InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) = 0;

            /**
             * Saves changes to prefab to disk.
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/EntityId.h>
+#include <AzCore/EBus/EBus.h>
+#include <AzCore/Math/Vector3.h>
+#include <AzCore/std/containers/vector.h>
+#include <AzCore/std/string/string_view.h>
+
+namespace AzToolsFramework
+{
+    namespace Prefab
+    {
+        /**
+        * The primary purpose of this bus is to facilitate writing automated tests for prefabs.
+        * It calls PrefabPublicInterface internally to talk to the prefab system.
+        * If you would like to integrate prefabs into your system, please call PrefabPublicInterface
+        * directly for better performance.
+        */
+        class PrefabPublicRequests
+            : public AZ::EBusTraits
+        {
+        public:
+            using Bus = AZ::EBus<PrefabPublicRequests>;
+
+            //////////////////////////////////////////////////////////////////////////
+            // EBusTraits overrides
+            static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+            //////////////////////////////////////////////////////////////////////////
+
+            virtual ~PrefabPublicRequests() = default;
+
+            /**
+             * Create a prefab out of the entities provided, at the path provided, and keep it in memory.
+             * Automatically detects descendants of entities, and discerns between entities and child instances.
+             */
+            virtual bool CreatePrefabInMemory(
+                const AZStd::vector<AZ::EntityId>& entityIds, AZStd::string_view filePath) = 0;
+
+            /**
+             * Instantiate a prefab from a prefab file.
+             */
+            virtual AZ::EntityId InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) = 0;
+        };
+
+        using PrefabPublicRequestBus = AZ::EBus<PrefabPublicRequests>;
+
+    } // namespace Prefab
+} // namespace AzToolsFramework
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/Prefab/PrefabPublicRequestHandler.h>
+
+#include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
+
+namespace AzToolsFramework
+{
+    namespace Prefab
+    {
+        void PrefabPublicRequestHandler::Reflect(AZ::ReflectContext* context)
+        {
+            AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context);
+            if (behaviorContext)
+            {
+                behaviorContext->EBus<PrefabPublicRequestBus>("PrefabPublicRequestBus")
+                    ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Automation)
+                    ->Attribute(AZ::Script::Attributes::Category, "Prefab")
+                    ->Attribute(AZ::Script::Attributes::Module, "prefab")
+                    ->Event("CreatePrefabInMemory", &PrefabPublicRequests::CreatePrefabInMemory)
+                    ->Event("InstantiatePrefab", &PrefabPublicRequests::InstantiatePrefab)
+                    ;
+            }
+        }
+
+        void PrefabPublicRequestHandler::Connect()
+        {
+            m_prefabPublicInterface = AZ::Interface<Prefab::PrefabPublicInterface>::Get();
+            AZ_Assert(m_prefabPublicInterface, "PrefabPublicRequestHandler - Could not retrieve instance of PrefabPublicInterface");
+
+            PrefabPublicRequestBus::Handler::BusConnect();
+        }
+
+        void PrefabPublicRequestHandler::Disconnect()
+        {
+            PrefabPublicRequestBus::Handler::BusDisconnect();
+
+            m_prefabPublicInterface = nullptr;
+        }
+
+        bool PrefabPublicRequestHandler::CreatePrefabInMemory(const AZStd::vector<AZ::EntityId>& entityIds, AZStd::string_view filePath)
+        {
+            auto createPrefabOutcome = m_prefabPublicInterface->CreatePrefabInMemory(entityIds, filePath);
+            if (!createPrefabOutcome.IsSuccess())
+            {
+                AZ_Error("CreatePrefabInMemory", false,
+                    "Failed to create Prefab on file path '%.*s'. Error message: %s.",
+                    AZ_STRING_ARG(filePath),
+                    createPrefabOutcome.GetError().c_str());
+
+                return false;
+            }
+
+            return true;
+        }
+
+        AZ::EntityId PrefabPublicRequestHandler::InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position)
+        {
+            auto instantiatePrefabOutcome = m_prefabPublicInterface->InstantiatePrefab(filePath, parent, position);
+            if (!instantiatePrefabOutcome.IsSuccess())
+            {
+                AZ_Error("InstantiatePrefab", false,
+                    "Failed to instantiate Prefab on file path '%.*s'. Error message: %s.",
+                    AZ_STRING_ARG(filePath),
+                    instantiatePrefabOutcome.GetError().c_str());
+
+                return AZ::EntityId();
+            }
+
+            return instantiatePrefabOutcome.GetValue();
+        }
+    } // namespace Prefab
+} // namespace AzToolsFramework
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Memory/SystemAllocator.h>
+#include <AzCore/RTTI/RTTI.h>
+
+#include <AzToolsFramework/Prefab/PrefabPublicRequestBus.h>
+
+namespace AzToolsFramework
+{
+    namespace Prefab
+    {
+        class PrefabPublicInterface;
+
+        class PrefabPublicRequestHandler final
+            : public PrefabPublicRequestBus::Handler
+        {
+        public:
+            AZ_CLASS_ALLOCATOR(PrefabPublicRequestHandler, AZ::SystemAllocator, 0);
+            AZ_RTTI(PrefabPublicRequestHandler, "{83FBDDF9-10BE-4373-B1DC-44B47EE4805C}");
+
+            static void Reflect(AZ::ReflectContext* context);
+
+            void Connect();
+            void Disconnect();
+
+            bool CreatePrefabInMemory(const AZStd::vector<AZ::EntityId>& entityIds, AZStd::string_view filePath) override;
+            AZ::EntityId InstantiatePrefab(AZStd::string_view filePath, AZ::EntityId parent, const AZ::Vector3& position) override;
+
+        private:
+            PrefabPublicInterface* m_prefabPublicInterface = nullptr;
+        };
+    } // namespace Prefab
+} // namespace AzToolsFramework
@@ -35,12 +35,14 @@ namespace AzToolsFramework
            m_instanceUpdateExecutor.RegisterInstanceUpdateExecutorInterface();
            m_instanceToTemplatePropagator.RegisterInstanceToTemplateInterface();
            m_prefabPublicHandler.RegisterPrefabPublicHandlerInterface();
+            m_prefabPublicRequestHandler.Connect();
            AZ::SystemTickBus::Handler::BusConnect();
        }

        void PrefabSystemComponent::Deactivate()
        {
            AZ::SystemTickBus::Handler::BusDisconnect();
+            m_prefabPublicRequestHandler.Disconnect();
            m_prefabPublicHandler.UnregisterPrefabPublicHandlerInterface();
            m_instanceToTemplatePropagator.UnregisterInstanceToTemplateInterface();
            m_instanceUpdateExecutor.UnregisterInstanceUpdateExecutorInterface();
@@ -54,6 +56,7 @@ namespace AzToolsFramework
            AzToolsFramework::Prefab::PrefabConversionUtils::PrefabConversionPipeline::Reflect(context);
            AzToolsFramework::Prefab::PrefabConversionUtils::PrefabCatchmentProcessor::Reflect(context);
            AzToolsFramework::Prefab::PrefabConversionUtils::EditorInfoRemover::Reflect(context);
+            PrefabPublicRequestHandler::Reflect(context);

            AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context);
            if (serialize)
@@ -62,7 +65,6 @@ namespace AzToolsFramework
            }

            AZ::JsonRegistrationContext* jsonRegistration = azrtti_cast<AZ::JsonRegistrationContext*>(context);
-
            if (jsonRegistration)
            {
                jsonRegistration->Serializer<JsonInstanceSerializer>()->HandlesType<Instance>();
@@ -24,6 +24,7 @@
 #include <AzToolsFramework/Prefab/PrefabIdTypes.h>
 #include <AzToolsFramework/Prefab/PrefabLoader.h>
 #include <AzToolsFramework/Prefab/PrefabPublicHandler.h>
+#include <AzToolsFramework/Prefab/PrefabPublicRequestHandler.h>
 #include <AzToolsFramework/Prefab/PrefabSystemComponentInterface.h>
 #include <AzToolsFramework/Prefab/Template/Template.h>

@@ -369,6 +370,9 @@ namespace AzToolsFramework

            // Used for updating Templates when Instances are modified
            InstanceToTemplatePropagator m_instanceToTemplatePropagator;
+
+            // Handler of the public Prefab requests
+            PrefabPublicRequestHandler m_prefabPublicRequestHandler;
        };
    } // namespace Prefab
 } // namespace AzToolsFramework
@@ -256,11 +256,11 @@ namespace AzToolsFramework

        void PrefabIntegrationManager::HandleSourceFileType(AZStd::string_view sourceFilePath, AZ::EntityId parentId, AZ::Vector3 position) const
        {
-            auto createPrefabOutcome = s_prefabPublicInterface->InstantiatePrefab(sourceFilePath, parentId, position);
+            auto instantiatePrefabOutcome = s_prefabPublicInterface->InstantiatePrefab(sourceFilePath, parentId, position);

-            if (!createPrefabOutcome.IsSuccess())
+            if (!instantiatePrefabOutcome.IsSuccess())
            {
-                WarnUserOfError("Prefab Instantiation Error", createPrefabOutcome.GetError());
+                WarnUserOfError("Prefab Instantiation Error", instantiatePrefabOutcome.GetError());
            }
        }

@@ -348,7 +348,7 @@ namespace AzToolsFramework
                }
            }

-            auto createPrefabOutcome = s_prefabPublicInterface->CreatePrefab(selectedEntities, prefabFilePath.data());
+            auto createPrefabOutcome = s_prefabPublicInterface->CreatePrefabInDisk(selectedEntities, prefabFilePath.data());

            if (!createPrefabOutcome.IsSuccess())
            {
@@ -657,6 +657,9 @@ set(FILES
    Prefab/PrefabPublicHandler.cpp
    Prefab/PrefabPublicInterface.h
    Prefab/PrefabPublicNotificationBus.h
+    Prefab/PrefabPublicRequestBus.h
+    Prefab/PrefabPublicRequestHandler.h
+    Prefab/PrefabPublicRequestHandler.cpp
    Prefab/PrefabUndo.h
    Prefab/PrefabUndo.cpp
    Prefab/PrefabUndoCache.cpp