LYN-7483 + LYN-7052 | Correctly initialize and refresh Prefab Focus Mode handler. (#4718)

* Initialize the PrefabFocusHandler on context reset, to also cover the case of a new level being created on the welcome screen.
Relax checks/restrictions on refreshes to cover cases where an instance is reused by the Prefab EOS.
Refresh the breadcrumbs when a container is renamed and when a change is propagated to the instances to ensure the correct names are displayed.

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

* Rename m_isInitialized to m_initialized in PrefabFocusHandler

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

* Use find_if to detect when a container entity in the focus path has been renamed.

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

* Renaming and commenting variables in PrefabFocusHandler.

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

* Undo minor naming change

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

* Replace lazy initialization and have the UI side initialize the Editor calls in PrefabFocusHandler.
This should prevent issues with focus mode trying to access these interfaces in non-editor applications.

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp

@@ -53,7 +53,7 @@ namespace AzToolsFramework
         AZ_Assert(m_loaderInterface != nullptr,
             "Couldn't get prefab loader interface, it's a requirement for PrefabEntityOwnership system to work");
 
-        m_rootInstance = AZStd::unique_ptr<Prefab::Instance>(m_prefabSystemComponent->CreatePrefab({}, {}, "NewLevel.prefab"));
+        m_rootInstance = AZStd::unique_ptr<Prefab::Instance>(m_prefabSystemComponent->CreatePrefab({}, {}, "newLevel.prefab"));
         m_sliceOwnershipService.BusConnect(m_entityContextId);
         m_sliceOwnershipService.m_shouldAssertForLegacySlicesUsage = m_shouldAssertForLegacySlicesUsage;
         m_editorSliceOwnershipService.BusConnect();

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusHandler.cpp

@@ -28,7 +28,9 @@ namespace AzToolsFramework::Prefab
             "Instance Entity Mapper Interface could not be found. "
             "Check that it is being correctly initialized.");
 
+        EditorEntityInfoNotificationBus::Handler::BusConnect();
         EditorEntityContextNotificationBus::Handler::BusConnect();
+        PrefabPublicNotificationBus::Handler::BusConnect();
         AZ::Interface<PrefabFocusInterface>::Register(this);
         AZ::Interface<PrefabFocusPublicInterface>::Register(this);
     }
@@ -37,10 +39,12 @@ namespace AzToolsFramework::Prefab
     {
         AZ::Interface<PrefabFocusPublicInterface>::Unregister(this);
         AZ::Interface<PrefabFocusInterface>::Unregister(this);
+        PrefabPublicNotificationBus::Handler::BusDisconnect();
         EditorEntityContextNotificationBus::Handler::BusDisconnect();
+        EditorEntityInfoNotificationBus::Handler::BusDisconnect();
     }
 
-    void PrefabFocusHandler::Initialize()
+    void PrefabFocusHandler::InitializeEditorInterfaces()
     {
         m_containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get();
         AZ_Assert(
@@ -55,13 +59,6 @@ namespace AzToolsFramework::Prefab
             "Prefab - PrefabFocusHandler - "
             "Focus Mode Interface could not be found. "
             "Check that it is being correctly initialized.");
-
-        m_instanceEntityMapperInterface = AZ::Interface<InstanceEntityMapperInterface>::Get();
-        AZ_Assert(
-            m_instanceEntityMapperInterface,
-            "Prefab - PrefabFocusHandler - "
-            "Instance Entity Mapper Interface could not be found. "
-            "Check that it is being correctly initialized.");
     }
 
     PrefabFocusOperationResult PrefabFocusHandler::FocusOnOwningPrefab(AZ::EntityId entityId)
@@ -90,12 +87,12 @@ namespace AzToolsFramework::Prefab
 
     PrefabFocusOperationResult PrefabFocusHandler::FocusOnPathIndex([[maybe_unused]] AzFramework::EntityContextId entityContextId, int index)
     {
-        if (index < 0 || index >= m_instanceFocusVector.size())
+        if (index < 0 || index >= m_instanceFocusHierarchy.size())
         {
             return AZ::Failure(AZStd::string("Prefab Focus Handler: Invalid index on FocusOnPathIndex."));
         }
 
-        InstanceOptionalReference focusedInstance = m_instanceFocusVector[index];
+        InstanceOptionalReference focusedInstance = m_instanceFocusHierarchy[index];
 
         FocusOnOwningPrefab(focusedInstance->get().GetContainerEntityId());
 
@@ -134,42 +131,38 @@ namespace AzToolsFramework::Prefab
             return AZ::Failure(AZStd::string("Prefab Focus Handler: invalid instance to focus on."));
         }
 
-        if (!m_isInitialized)
+        // Close all container entities in the old path.
+        CloseInstanceContainers(m_instanceFocusHierarchy);
+
+        m_focusedInstance = focusedInstance;
+        m_focusedTemplateId = focusedInstance->get().GetTemplateId();
+
+        AZ::EntityId containerEntityId;
+
+        if (focusedInstance->get().GetParentInstance() != AZStd::nullopt)
         {
-            Initialize();
+            containerEntityId = focusedInstance->get().GetContainerEntityId();
         }
-
-        if (!m_focusedInstance.has_value() || &m_focusedInstance->get() != &focusedInstance->get())
+        else
         {
-            // Close all container entities in the old path
-            CloseInstanceContainers(m_instanceFocusVector);
-
-            m_focusedInstance = focusedInstance;
-            m_focusedTemplateId = focusedInstance->get().GetTemplateId();
-
-            AZ::EntityId containerEntityId;
-
-            if (focusedInstance->get().GetParentInstance() != AZStd::nullopt)
-            {
-                containerEntityId = focusedInstance->get().GetContainerEntityId();
-            }
-            else
-            {
-                containerEntityId = AZ::EntityId();
-            }
+            containerEntityId = AZ::EntityId();
+        }
             
-            // Focus on the descendants of the container entity
+        // Focus on the descendants of the container entity in the Editor, if the interface is initialized.
+        if (m_focusModeInterface)
+        {
             m_focusModeInterface->SetFocusRoot(containerEntityId);
-
-            // Refresh path variables
-            RefreshInstanceFocusList();
-
-            // Open all container entities in the new path
-            OpenInstanceContainers(m_instanceFocusVector);
-
-            PrefabFocusNotificationBus::Broadcast(&PrefabFocusNotifications::OnPrefabFocusChanged);
         }
 
+        // Refresh path variables.
+        RefreshInstanceFocusList();
+        RefreshInstanceFocusPath();
+
+        // Open all container entities in the new path.
+        OpenInstanceContainers(m_instanceFocusHierarchy);
+
+        PrefabFocusNotificationBus::Broadcast(&PrefabFocusNotifications::OnPrefabFocusChanged);
+
         return AZ::Success();
     }
     
@@ -220,49 +213,80 @@ namespace AzToolsFramework::Prefab
 
     const int PrefabFocusHandler::GetPrefabFocusPathLength([[maybe_unused]] AzFramework::EntityContextId entityContextId) const
     {
-        return aznumeric_cast<int>(m_instanceFocusVector.size());
+        return aznumeric_cast<int>(m_instanceFocusHierarchy.size());
     }
 
-    void PrefabFocusHandler::OnEntityStreamLoadSuccess()
+    void PrefabFocusHandler::OnContextReset()
     {
-        if (!m_isInitialized)
-        {
-            Initialize();
-        }
-
         // Clear the old focus vector
-        m_instanceFocusVector.clear();
+        m_instanceFocusHierarchy.clear();
 
         // Focus on the root prefab (AZ::EntityId() will default to it)
         FocusOnPrefabInstanceOwningEntityId(AZ::EntityId());
     }
 
+    void PrefabFocusHandler::OnEntityInfoUpdatedName(AZ::EntityId entityId, [[maybe_unused]]const AZStd::string& name)
+    {
+        // Determine if the entityId is the container for any of the instances in the vector
+        auto result = AZStd::find_if(
+            m_instanceFocusHierarchy.begin(), m_instanceFocusHierarchy.end(),
+            [entityId](const InstanceOptionalReference& instance)
+            {
+                return (instance->get().GetContainerEntityId() == entityId);
+            }
+        );
+
+        if (result != m_instanceFocusHierarchy.end())
+        {
+            // Refresh the path and notify changes.
+            RefreshInstanceFocusPath();
+            PrefabFocusNotificationBus::Broadcast(&PrefabFocusNotifications::OnPrefabFocusChanged);
+        }
+    }
+
+    void PrefabFocusHandler::OnPrefabInstancePropagationEnd()
+    {
+        // Refresh the path and notify changes in case propagation updated any container names.
+        RefreshInstanceFocusPath();
+        PrefabFocusNotificationBus::Broadcast(&PrefabFocusNotifications::OnPrefabFocusChanged);
+    }
+
     void PrefabFocusHandler::RefreshInstanceFocusList()
     {
-        m_instanceFocusVector.clear();
-        m_instanceFocusPath.clear();
+        m_instanceFocusHierarchy.clear();
 
         AZStd::list<InstanceOptionalReference> instanceFocusList;
 
-        // Use a support list to easily push front while traversing the prefab hierarchy
         InstanceOptionalReference currentInstance = m_focusedInstance;
         while (currentInstance.has_value())
         {
-            instanceFocusList.push_front(currentInstance);
+            m_instanceFocusHierarchy.emplace_back(currentInstance);
 
             currentInstance = currentInstance->get().GetParentInstance();
         }
 
-        // Populate internals using the support list
-        for (auto& instance : instanceFocusList)
+        // Invert the vector, since we need the top instance to be at index 0
+        AZStd::reverse(m_instanceFocusHierarchy.begin(), m_instanceFocusHierarchy.end());
+    }
+
+    void PrefabFocusHandler::RefreshInstanceFocusPath()
+    {
+        m_instanceFocusPath.clear();
+
+        for (const InstanceOptionalReference& instance : m_instanceFocusHierarchy)
         {
             m_instanceFocusPath.Append(instance->get().GetContainerEntity()->get().GetName());
-            m_instanceFocusVector.emplace_back(instance);
         }
     }
 
     void PrefabFocusHandler::OpenInstanceContainers(const AZStd::vector<InstanceOptionalReference>& instances) const
     {
+        // If this is called outside the Editor, this interface won't be initialized.
+        if (!m_containerEntityInterface)
+        {
+            return;
+        }
+
         for (const InstanceOptionalReference& instance : instances)
         {
             if (instance.has_value())
@@ -274,6 +298,12 @@ namespace AzToolsFramework::Prefab
 
     void PrefabFocusHandler::CloseInstanceContainers(const AZStd::vector<InstanceOptionalReference>& instances) const
     {
+        // If this is called outside the Editor, this interface won't be initialized.
+        if (!m_containerEntityInterface)
+        {
+            return;
+        }
+
         for (const InstanceOptionalReference& instance : instances)
         {
             if (instance.has_value())

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusHandler.h

@@ -11,9 +11,11 @@
 #include <AzCore/Memory/SystemAllocator.h>
 
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
+#include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
 #include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
+#include <AzToolsFramework/Prefab/PrefabPublicNotificationBus.h>
 #include <AzToolsFramework/Prefab/Template/Template.h>
 
 namespace AzToolsFramework
@@ -30,7 +32,9 @@ namespace AzToolsFramework::Prefab
     class PrefabFocusHandler final
         : private PrefabFocusInterface
         , private PrefabFocusPublicInterface
+        , private PrefabPublicNotificationBus::Handler
         , private EditorEntityContextNotificationBus::Handler
+        , private EditorEntityInfoNotificationBus::Handler
     {
     public:
         AZ_CLASS_ALLOCATOR(PrefabFocusHandler, AZ::SystemAllocator, 0);
@@ -38,9 +42,8 @@ namespace AzToolsFramework::Prefab
         PrefabFocusHandler();
         ~PrefabFocusHandler();
 
-        void Initialize();
-
         // PrefabFocusInterface overrides ...
+        void InitializeEditorInterfaces() override;
         PrefabFocusOperationResult FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId) override;
         TemplateId GetFocusedPrefabTemplateId(AzFramework::EntityContextId entityContextId) const override;
         InstanceOptionalReference GetFocusedPrefabInstance(AzFramework::EntityContextId entityContextId) const override;
@@ -54,25 +57,34 @@ namespace AzToolsFramework::Prefab
         const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const override;
 
         // EditorEntityContextNotificationBus overrides ...
-        void OnEntityStreamLoadSuccess() override;
+        void OnContextReset() override;
+        
+        // EditorEntityInfoNotificationBus overrides ...
+        void OnEntityInfoUpdatedName(AZ::EntityId entityId, const AZStd::string& name) override;
+
+        // PrefabPublicNotifications overrides ...
+        void OnPrefabInstancePropagationEnd();
 
     private:
         PrefabFocusOperationResult FocusOnPrefabInstance(InstanceOptionalReference focusedInstance);
         void RefreshInstanceFocusList();
+        void RefreshInstanceFocusPath();
 
         void OpenInstanceContainers(const AZStd::vector<InstanceOptionalReference>& instances) const;
         void CloseInstanceContainers(const AZStd::vector<InstanceOptionalReference>& instances) const;
 
+        //! The instance the editor is currently focusing on.
         InstanceOptionalReference m_focusedInstance;
+        //! The templateId of the focused instance.
         TemplateId m_focusedTemplateId;
-        AZStd::vector<InstanceOptionalReference> m_instanceFocusVector;
+        //! The list of instances going from the root (index 0) to the focused instance.
+        AZStd::vector<InstanceOptionalReference> m_instanceFocusHierarchy;
+        //! A path containing the names of the containers in the instance focus hierarchy, separated with a /.
         AZ::IO::Path m_instanceFocusPath;
 
         ContainerEntityInterface* m_containerEntityInterface = nullptr;
         FocusModeInterface* m_focusModeInterface = nullptr;
         InstanceEntityMapperInterface* m_instanceEntityMapperInterface = nullptr;
-
-        bool m_isInitialized = false;
     };
 
 } // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusInterface.h

@@ -26,6 +26,11 @@ namespace AzToolsFramework::Prefab
     public:
         AZ_RTTI(PrefabFocusInterface, "{F3CFA37B-5FD8-436A-9C30-60EB54E350E1}");
 
+        //! Initializes the editor interfaces for Prefab Focus mode.
+        //! If this is not called on initialization, the Prefab Focus Mode functions will still work
+        //! but won't trigger the Editor APIs to visualize focus mode on the UI.
+        virtual void InitializeEditorInterfaces() = 0;
+
         //! Set the focused prefab instance to the owning instance of the entityId provided.
         //! @param entityId The entityId of the entity whose owning instance we want the prefab system to focus on.
         virtual PrefabFocusOperationResult FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId) = 0;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp

@@ -27,6 +27,7 @@
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/Prefab/EditorPrefabComponent.h>
 #include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 #include <AzToolsFramework/Prefab/PrefabLoaderInterface.h>
 #include <AzToolsFramework/Prefab/Procedural/ProceduralPrefabAsset.h>
@@ -135,6 +136,10 @@ namespace AzToolsFramework
                 return;
             }
 
+            // Initialize Editor functionality for the Prefab Focus Handler
+            auto prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
+            prefabFocusInterface->InitializeEditorInterfaces();
+
             EditorContextMenuBus::Handler::BusConnect();
             EditorEventsBus::Handler::BusConnect();
             PrefabInstanceContainerNotificationBus::Handler::BusConnect();