Solidify keying Remote Tools portion of API and begin migrating Lua IDE

Signed-off-by: puvvadar <[email protected]>

Code/Framework/AzFramework/AzFramework/Network/IRemoteTools.h

@@ -148,46 +148,45 @@ namespace AzFramework
     using RemoteToolsEndpointConnectedEvent = AZ::Event<bool>;
     using RemoteToolsEndpointChangedEvent = AZ::Event<AZ::u32, AZ::u32>;
     using ReceivedRemoteToolsMessages = AZStd::fixed_vector<RemoteToolsMessagePointer, 64>;
-    using RemoteToolsServiceKey = AZ::u32;
 
     class IRemoteTools
     {
     public:
         AZ_RTTI(IRemoteTools, "{1446BADE-E6F7-4E3C-8D37-669A544DB964}");
 
-        virtual RemoteToolsServiceKey RegisterToolingService(AZStd::string name, uint16_t port) = 0;
+        virtual void RegisterToolingService(AZ::Crc32 key, AZ::Name name, uint16_t port) = 0;
 
-        virtual const ReceivedRemoteToolsMessages* GetReceivedMessages(RemoteToolsServiceKey key) const = 0;
+        virtual const ReceivedRemoteToolsMessages* GetReceivedMessages(AZ::Crc32 key) const = 0;
 
-        virtual void ClearReceivedMessages(RemoteToolsServiceKey key) = 0;
+        virtual void ClearReceivedMessages(AZ::Crc32 key) = 0;
 
-        virtual void RegisterRemoteToolsEndpointJoinedHandler(RemoteToolsServiceKey key, RemoteToolsEndpointStatusEvent::Handler handler) = 0;
+        virtual void RegisterRemoteToolsEndpointJoinedHandler(AZ::Crc32 key, RemoteToolsEndpointStatusEvent::Handler handler) = 0;
 
-        virtual void RegisterRemoteToolsEndpointLeftHandler(RemoteToolsServiceKey key, RemoteToolsEndpointStatusEvent::Handler handler) = 0;
+        virtual void RegisterRemoteToolsEndpointLeftHandler(AZ::Crc32 key, RemoteToolsEndpointStatusEvent::Handler handler) = 0;
 
-        virtual void RegisterRemoteToolsEndpointConnectedHandler(RemoteToolsServiceKey key, RemoteToolsEndpointConnectedEvent::Handler handler) = 0;
+        virtual void RegisterRemoteToolsEndpointConnectedHandler(AZ::Crc32 key, RemoteToolsEndpointConnectedEvent::Handler handler) = 0;
 
-        virtual void RegisterRemoteToolsEndpointChangedHandler(RemoteToolsServiceKey key, RemoteToolsEndpointChangedEvent::Handler handler) = 0;
+        virtual void RegisterRemoteToolsEndpointChangedHandler(AZ::Crc32 key, RemoteToolsEndpointChangedEvent::Handler handler) = 0;
 
         // call this function to retrieve the list of currently known targets - this is mainly used for GUIs
         // when they come online and attempt to enum (they won't have been listening for target coming and going)
         // you will only be shown targets that have been seen in a reasonable amount of time.
-        virtual void EnumTargetInfos(RemoteToolsServiceKey key, RemoteToolsEndpointContainer& infos) = 0;
+        virtual void EnumTargetInfos(AZ::Crc32 key, RemoteToolsEndpointContainer& infos) = 0;
 
         // set the desired target, which we'll specifically keep track of.
         // the target controls who gets lua commands, tweak stuff, that kind of thing
-        virtual void SetDesiredEndpoint(RemoteToolsServiceKey key, AZ::u32 desiredTargetID) = 0;
+        virtual void SetDesiredEndpoint(AZ::Crc32 key, AZ::u32 desiredTargetID) = 0;
 
-        virtual void SetDesiredEndpointInfo(RemoteToolsServiceKey key, const RemoteToolsEndpointInfo& targetInfo) = 0;
+        virtual void SetDesiredEndpointInfo(AZ::Crc32 key, const RemoteToolsEndpointInfo& targetInfo) = 0;
 
         // retrieve what it was set to.
-        virtual RemoteToolsEndpointInfo GetDesiredEndpoint(RemoteToolsServiceKey key) = 0;
+        virtual RemoteToolsEndpointInfo GetDesiredEndpoint(AZ::Crc32 key) = 0;
 
         // given id, get info.
-        virtual RemoteToolsEndpointInfo GetEndpointInfo(RemoteToolsServiceKey key, AZ::u32 desiredTargetID) = 0;
+        virtual RemoteToolsEndpointInfo GetEndpointInfo(AZ::Crc32 key, AZ::u32 desiredTargetID) = 0;
 
         // check if target is online
-        virtual bool IsEndpointOnline(RemoteToolsServiceKey key, AZ::u32 desiredTargetID) = 0;
+        virtual bool IsEndpointOnline(AZ::Crc32 key, AZ::u32 desiredTargetID) = 0;
 
         // send a message to a remote target
         virtual void SendRemoteToolsMessage(const RemoteToolsEndpointInfo& target, const RemoteToolsMessage& msg) = 0;

Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp

@@ -12,7 +12,6 @@
 #include <AzCore/Utils/Utils.h>
 
 #include <AzFramework/Archive/Archive.h>
-#include <AzFramework/TargetManagement/TargetManagementComponent.h>
 #include <AzGameFramework/AzGameFrameworkModule.h>
 
 namespace AzGameFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp

@@ -14,7 +14,6 @@
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/Debug/Profiler.h>
 
-#include <AzFramework/TargetManagement/TargetManagementComponent.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 
 #include <AzToolsFramework/AzToolsFrameworkModule.h>

Code/Framework/AzToolsFramework/AzToolsFramework/AzToolsFrameworkModule.cpp

@@ -9,8 +9,6 @@
 #include <AzToolsFramework/AzToolsFrameworkModule.h>
 
  // Component includes
-#include <AzFramework/TargetManagement/TargetManagementComponent.h>
-
 #include <AzToolsFramework/ActionManager/ActionManagerSystemComponent.h>
 #include <AzToolsFramework/Archive/ArchiveComponent.h>
 #include <AzToolsFramework/Asset/AssetSystemComponent.h>

Code/Framework/AzToolsFramework/AzToolsFramework/UI/LegacyFramework/Core/EditorFrameworkApplication.cpp

@@ -34,7 +34,6 @@
 
 #include <AzFramework/Asset/AssetCatalogComponent.h>
 #include <AzFramework/StringFunc/StringFunc.h>
-#include <AzFramework/TargetManagement/TargetManagementComponent.h>
 
 #ifdef AZ_PLATFORM_WINDOWS
 #include "shlobj.h"
@@ -491,7 +490,6 @@ namespace LegacyFramework
     {
         ComponentApplication::RegisterCoreComponents();
 
-        RegisterComponentDescriptor(AzFramework::TargetManagementComponent::CreateDescriptor());
         RegisterComponentDescriptor(AzToolsFramework::Framework::CreateDescriptor());
     }
 }

Code/Framework/AzToolsFramework/AzToolsFramework/UI/UICore/TargetSelectorButton.cpp

@@ -7,6 +7,7 @@
  */
 
 
+#include <AzCore/Interface/Interface.h>
 #include <AzCore/std/string/string.h>
 
 #include "TargetSelectorButton.hxx"
@@ -16,10 +17,10 @@
 
 namespace AzToolsFramework
 {
-    TargetSelectorButton::TargetSelectorButton(QWidget *pParent) 
+    TargetSelectorButton::TargetSelectorButton(AZ::Crc32 key, QWidget *pParent) 
         : QPushButton(pParent)
+        , m_remoteToolsKey(key)
     {
-        AzFramework::TargetManagerClient::Bus::Handler::BusConnect();
         UpdateStatus();
         this->setToolTip(tr("Click to change target"));
         connect(this, SIGNAL(clicked()), this, SLOT(DoPopup()));
@@ -32,16 +33,11 @@ namespace AzToolsFramework
         setMinimumSize(QSize(128, 24));
     }
 
-    TargetSelectorButton::~TargetSelectorButton()
-    {
-        AzFramework::TargetManagerClient::Bus::Handler::BusDisconnect();
-    }
-
     void TargetSelectorButton::DoPopup()
     {
-        AzFramework::TargetContainer targets;
+        AzFramework::RemoteToolsEndpointContainer targets;
 
-        EBUS_EVENT(AzFramework::TargetManager::Bus, EnumTargetInfos, targets);
+        AzFramework::RemoteToolsInterface::Get()->EnumTargetInfos(m_remoteToolsKey, targets);
 
         QMenu menu;
 
@@ -50,17 +46,16 @@ namespace AzToolsFramework
 
         menu.addAction(pNoneAction);
 
-        for (AzFramework::TargetContainer::const_iterator it = targets.begin(); it != targets.end(); ++it)
+        for (AzFramework::RemoteToolsEndpointContainer::const_iterator it = targets.begin(); it != targets.end(); ++it)
         {
-            const AzFramework::TargetInfo& info = it->second;
-            bool isSelf = (info.GetStatusFlags() & AzFramework::TF_SELF) != 0;
-            if (isSelf)
+            const AzFramework::RemoteToolsEndpointInfo& info = it->second;
+            if (info.IsSelf())
             {
                 // Do not list the current application as a target
                 continue;
             }
 
-            bool isOnline = (info.GetStatusFlags() & AzFramework::TF_ONLINE) != 0;
+            bool isOnline = AzFramework::RemoteToolsInterface::Get()->IsEndpointOnline(m_remoteToolsKey, info.GetNetworkId());
 
             QString displayTargetString;
             ConstructDisplayTargetString(displayTargetString, info);
@@ -75,7 +70,7 @@ namespace AzToolsFramework
         if (resultAction)
         {
             AZ::u32 networkId = resultAction->property("targetID").toUInt();
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SetDesiredTarget, networkId);
+            AzFramework::RemoteToolsInterface::Get()->SetDesiredEndpoint(m_remoteToolsKey, networkId);
         }
     }
 
@@ -89,8 +84,7 @@ namespace AzToolsFramework
             return;
         }
 
-        AzFramework::TargetInfo info;
-        EBUS_EVENT_RESULT(info, AzFramework::TargetManager::Bus, GetDesiredTarget);
+        AzFramework::RemoteToolsEndpointInfo info = AzFramework::RemoteToolsInterface::Get()->GetDesiredEndpoint(m_remoteToolsKey);
         if (!info.GetPersistentId())
         {
             this->setIcon(QIcon(":/general/target_none"));
@@ -109,7 +103,7 @@ namespace AzToolsFramework
         ConstructDisplayTargetString(displayTargetString, info);
 
         this->setText(QString("Target: %1").arg(displayTargetString));
-        if (info.GetStatusFlags() & AzFramework::TF_ONLINE)
+        if (AzFramework::RemoteToolsInterface::Get()->IsEndpointOnline(m_remoteToolsKey, info.GetNetworkId()))
         {
             this->setIcon(QIcon(":/general/target_connected"));
         }
@@ -121,8 +115,7 @@ namespace AzToolsFramework
 
     void TargetSelectorButton::UpdateStatus()
     {
-        AzFramework::TargetInfo info;
-        EBUS_EVENT_RESULT(info, AzFramework::TargetManager::Bus, GetDesiredTarget);
+        AzFramework::RemoteToolsEndpointInfo info = AzFramework::RemoteToolsInterface::Get()->GetDesiredEndpoint(m_remoteToolsKey);
         if (!info.GetPersistentId())
         {
             this->setIcon(QIcon(":/general/target_none"));
@@ -138,7 +131,7 @@ namespace AzToolsFramework
         }
 
         this->setText(QString("Target: %1").arg(info.GetDisplayName()));
-        if (info.GetStatusFlags() & AzFramework::TF_ONLINE)
+        if (AzFramework::RemoteToolsInterface::Get()->IsEndpointOnline(m_remoteToolsKey, info.GetNetworkId()))
         {
             this->setIcon(QIcon(":/general/target_connected"));
         }
@@ -149,18 +142,19 @@ namespace AzToolsFramework
         //updateGeometry();
     }
 
-    void TargetSelectorButton::ConstructDisplayTargetString(QString& outputString, const AzFramework::TargetInfo& info)
+    void TargetSelectorButton::ConstructDisplayTargetString(QString& outputString, const AzFramework::RemoteToolsEndpointInfo& info)
     {
         outputString = QString("%1 (%2)").arg(info.GetDisplayName()).arg(QString::number(static_cast<unsigned int>(info.GetPersistentId()),16));
     }
 
-    TargetSelectorButtonAction::TargetSelectorButtonAction(QObject *pParent) : QWidgetAction(pParent)
+    TargetSelectorButtonAction::TargetSelectorButtonAction(AZ::Crc32 key, QObject *pParent) : QWidgetAction(pParent)
     {
+        m_remoteToolsKey = key;
     }    
 
     QWidget* TargetSelectorButtonAction::createWidget(QWidget* pParent)
     {
-        return aznew TargetSelectorButton(pParent);
+        return aznew TargetSelectorButton(m_remoteToolsKey, pParent);
     }
 
 }

Code/Framework/AzToolsFramework/AzToolsFramework/UI/UICore/TargetSelectorButton.hxx

@@ -12,7 +12,7 @@
 #if !defined(Q_MOC_RUN)
 #include <AzCore/base.h>
 #include <AzCore/Memory/SystemAllocator.h>
-#include "AzFramework/TargetManagement/TargetManagementAPI.h"
+#include <AzFramework/Network/IRemoteTools.h>
 #include <QtWidgets/QPushButton>
 #include <qwidgetaction.h>
 #endif
@@ -23,21 +23,22 @@ namespace AzToolsFramework
 {
     class TargetSelectorButton
         : public QPushButton
-        , private AzFramework::TargetManagerClient::Bus::Handler
     {
         Q_OBJECT
     public:
         AZ_CLASS_ALLOCATOR(TargetSelectorButton, AZ::SystemAllocator, 0);
 
-        TargetSelectorButton(QWidget* pParent = 0);
-        virtual ~TargetSelectorButton();
+        TargetSelectorButton(AZ::Crc32 key, QWidget* pParent = 0);
+        virtual ~TargetSelectorButton() = default;
 
         // implement AzFramework::TargetManagerClient::Bus::Handler
         void DesiredTargetConnected(bool connected);
 
     private:
         void UpdateStatus();
-        void ConstructDisplayTargetString(QString& outputString, const AzFramework::TargetInfo& info);
+        void ConstructDisplayTargetString(QString& outputString, const AzFramework::RemoteToolsEndpointInfo& info);
+
+        AZ::Crc32 m_remoteToolsKey;
 
     private slots:
         void DoPopup();
@@ -51,10 +52,13 @@ namespace AzToolsFramework
     public:
         AZ_CLASS_ALLOCATOR(TargetSelectorButtonAction, AZ::SystemAllocator, 0);
 
-        TargetSelectorButtonAction(QObject* pParent);                                     // create default action
+        TargetSelectorButtonAction(AZ::Crc32 key, QObject* pParent); // create default action
 
     protected:
         virtual QWidget* createWidget(QWidget* pParent);
+
+    private:
+        AZ::Crc32 m_remoteToolsKey;
     };
 }
 

Code/Tools/LuaIDE/CMakeLists.txt

@@ -26,6 +26,7 @@ ly_add_target(
             .
             Source/Editor
             Source/LUA
+            Source/Utils
     BUILD_DEPENDENCIES
         PRIVATE
             Legacy::CryCommon

Code/Tools/LuaIDE/Source/LUA/LUADebuggerComponent.cpp

@@ -8,7 +8,9 @@
 
 #include "LUADebuggerComponent.h"
 #include "LUAEditorContextMessages.h"
+#include <Source/Utils/LuaIDEConstants.h>
 
+#include <AzCore/Interface/Interface.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/PlatformIncl.h>
@@ -19,7 +21,6 @@
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Script/ScriptContext.h>
 
-#include <AzFramework/TargetManagement/TargetManagementAPI.h>
 #include <AzFramework/Script/ScriptDebugMsgReflection.h>
 
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
@@ -29,11 +30,10 @@ namespace LUADebugger
 {
     // Utility functions
     // Returns true if a valid target was found, in which case the info is returned in targetInfo.
-    bool GetDesiredTarget(AzFramework::TargetInfo& targetInfo)
+    bool GetDesiredTarget(AzFramework::RemoteToolsEndpointInfo& targetInfo)
     {
         // discover what target the user is currently connected to, if any?
-        AzFramework::TargetInfo info;
-        EBUS_EVENT_RESULT(info, AzFramework::TargetManager::Bus, GetDesiredTarget);
+        AzFramework::RemoteToolsEndpointInfo info = AzFramework::RemoteToolsInterface::Get()->GetDesiredEndpoint(LuaToolsKey);
         if (!info.GetPersistentId())
         {
             AZ_TracePrintf("Debug", "The user has not chosen a target to connect to.\n");
@@ -42,9 +42,7 @@ namespace LUADebugger
 
         targetInfo = info;
         if (
-            (!targetInfo.IsValid()) ||
-            ((targetInfo.GetStatusFlags() & AzFramework::TF_ONLINE) == 0) ||
-            ((targetInfo.GetStatusFlags() & AzFramework::TF_DEBUGGABLE) == 0)
+            (!targetInfo.IsValid())
             )
         {
             AZ_TracePrintf("Debug", "The target is currently not in a state that would allow debugging code (offline or not debuggable)\n");
@@ -70,25 +68,21 @@ namespace LUADebugger
     void Component::Activate()
     {
         LUAEditorDebuggerMessages::Bus::Handler::BusConnect();
-        AzFramework::TargetManagerClient::Bus::Handler::BusConnect();
-        AzFramework::TmMsgBus::Handler::BusConnect(AZ_CRC("ScriptDebugger", 0xf8ab685e));
     }
 
     void Component::Deactivate()
     {
         LUAEditorDebuggerMessages::Bus::Handler::BusDisconnect();
-        AzFramework::TargetManagerClient::Bus::Handler::BusDisconnect();
-        AzFramework::TmMsgBus::Handler::BusDisconnect(AZ_CRC("ScriptDebugger", 0xf8ab685e));
     }
 
     void Component::EnumerateContexts()
     {
         AZ_TracePrintf("LUA Debug", "Component::EnumerateContexts()\n");
 
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumContexts", 0xbdb959ba)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumContexts", 0xbdb959ba)));
         }
     }
 
@@ -97,10 +91,10 @@ namespace LUADebugger
         AZ_TracePrintf("LUA Debug", "Component::AttachDebugger( %s )\n", scriptContextName);
 
         AZ_Assert(scriptContextName, "You need to supply a valid script context name to attach to!");
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("AttachDebugger", 0x6590ff36), scriptContextName));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("AttachDebugger", 0x6590ff36), scriptContextName));
         }
     }
 
@@ -108,37 +102,37 @@ namespace LUADebugger
     {
         AZ_TracePrintf("LUA Debug", "Component::DetachDebugger()\n");
 
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("DetachDebugger", 0x88a2ee04)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("DetachDebugger", 0x88a2ee04)));
         }
     }
 
     void Component::EnumRegisteredClasses(const char* scriptContextName)
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumRegisteredClasses", 0xed6b8070), scriptContextName));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumRegisteredClasses", 0xed6b8070), scriptContextName));
         }
     }
 
     void Component::EnumRegisteredEBuses(const char* scriptContextName)
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumRegisteredEBuses"), scriptContextName));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumRegisteredEBuses"), scriptContextName));
         }
     }
 
     void Component::EnumRegisteredGlobals(const char* scriptContextName)
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumRegisteredGlobals", 0x80d1e6af), scriptContextName));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumRegisteredGlobals", 0x80d1e6af), scriptContextName));
         }
     }
 
@@ -151,12 +145,12 @@ namespace LUADebugger
         EBUS_EVENT(AzToolsFramework::AssetSystemRequestBus, GetRelativeProductPathFromFullSourceOrProductPath, debugName, relativePath);
         relativePath = "@" + relativePath;
 
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
             // local editors are never debuggable (they'd never have the debuggable flag) so if you get here you know its over the network
             // and its network id is targetID.
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugBreakpointRequest(AZ_CRC("AddBreakpoint", 0xba71daa4), relativePath.c_str(), static_cast<AZ::u32>(lineNumber)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugBreakpointRequest(AZ_CRC("AddBreakpoint", 0xba71daa4), relativePath.c_str(), static_cast<AZ::u32>(lineNumber)));
         }
     }
 
@@ -169,39 +163,39 @@ namespace LUADebugger
         EBUS_EVENT(AzToolsFramework::AssetSystemRequestBus, GetRelativeProductPathFromFullSourceOrProductPath, debugName, relativePath);
         relativePath = "@" + relativePath;
 
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
             // local editors are never debuggable (they'd never have the debuggable flag) so if you get here you know its over the network
             // and its network id is targetID.
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugBreakpointRequest(AZ_CRC("RemoveBreakpoint", 0x90ade500), relativePath.c_str(), static_cast<AZ::u32>(lineNumber)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugBreakpointRequest(AZ_CRC("RemoveBreakpoint", 0x90ade500), relativePath.c_str(), static_cast<AZ::u32>(lineNumber)));
         }
     }
 
     void Component::DebugRunStepOver()
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("StepOver", 0x6b89bf41)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("StepOver", 0x6b89bf41)));
         }
     }
 
     void Component::DebugRunStepIn()
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("StepIn", 0x761a6b13)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("StepIn", 0x761a6b13)));
         }
     }
 
     void Component::DebugRunStepOut()
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("StepOut", 0xac19b635)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("StepOut", 0xac19b635)));
         }
     }
 
@@ -212,53 +206,53 @@ namespace LUADebugger
 
     void Component::DebugRunContinue()
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("Continue", 0x13e32adf)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("Continue", 0x13e32adf)));
         }
     }
 
     void Component::EnumLocals()
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumLocals", 0x4aa29dcf)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("EnumLocals", 0x4aa29dcf)));
         }
     }
 
     void Component::GetValue(const AZStd::string& varName)
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("GetValue", 0x2d64f577), varName.c_str()));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("GetValue", 0x2d64f577), varName.c_str()));
         }
     }
 
     void Component::SetValue(const AZ::ScriptContextDebug::DebugValue& value)
     {
         (void)value;
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
             AzFramework::ScriptDebugSetValue request;
             request.m_value = value;
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, request);
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, request);
         }
     }
 
     void Component::GetCallstack()
     {
-        AzFramework::TargetInfo targetInfo;
+        AzFramework::RemoteToolsEndpointInfo targetInfo;
         if (GetDesiredTarget(targetInfo))
         {
-            EBUS_EVENT(AzFramework::TargetManager::Bus, SendTmMessage, targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("GetCallstack", 0x343b24f3)));
+            AzFramework::RemoteToolsInterface::Get()->SendRemoteToolsMessage(targetInfo, AzFramework::ScriptDebugRequest(AZ_CRC("GetCallstack", 0x343b24f3)));
         }
     }
 
-    void Component::OnReceivedMsg(AzFramework::TmMsgPtr msg)
+    void Component::OnReceivedMsg(AzFramework::RemoteToolsMessagePointer msg)
     {
         if (AzFramework::ScriptDebugAck* ack = azdynamic_cast<AzFramework::ScriptDebugAck*>(msg.get()))
         {

Code/Tools/LuaIDE/Source/LUA/LUADebuggerComponent.h

@@ -10,7 +10,7 @@
 #define LUADEBUGGER_COMPONENT_H
 
 #include "LUAEditorDebuggerMessages.h"
-#include <AzFramework/TargetManagement/TargetManagementAPI.h>
+#include <AzFramework/Network/IRemoteTools.h>
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/TickBus.h>
 
@@ -27,8 +27,6 @@ namespace LUADebugger
     class Component
         : public AZ::Component
         , public LUAEditor::LUAEditorDebuggerMessages::Bus::Handler
-        , public AzFramework::TargetManagerClient::Bus::Handler
-        , public AzFramework::TmMsgBus::Handler
     {
     public:
         AZ_COMPONENT(Component, "{7854C9F4-D7E5-4420-A14E-FA5B19822F39}");
@@ -90,10 +88,7 @@ namespace LUADebugger
         virtual void DesiredTargetChanged(AZ::u32 newTargetID, AZ::u32 oldTargetID);
         //////////////////////////////////////////////////////////////////////////
 
-        //////////////////////////////////////////////////////////////////////////
-        // TmMsgBus
-        virtual void OnReceivedMsg(AzFramework::TmMsgPtr msg);
-        //////////////////////////////////////////////////////////////////////////
+        virtual void OnReceivedMsg(AzFramework::RemoteToolsMessagePointer msg);
 
         static void Reflect(AZ::ReflectContext* reflection);
     };

Code/Tools/LuaIDE/Source/LUA/LUAEditorContext.cpp

@@ -36,6 +36,7 @@
 #include <AzToolsFramework/SourceControl/SourceControlAPI.h>
 
 #include <Source/LUA/LUALocalsTrackerMessages.h>
+#include <Source/Utils/LuaIDEConstants.h>
 
 #include <QMessageBox>
 #include <regex>
@@ -123,6 +124,22 @@ namespace LUAEditor
     {
         m_fileIO = AZ::IO::FileIOBase::GetInstance();
         AZ_Assert(m_fileIO, "FileIO system is not present, make sure a FileIO instance is set by the application.");
+
+        m_connectedEventHandler = AzFramework::RemoteToolsEndpointConnectedEvent::Handler(
+            [this](bool value)
+            {
+                this->DesiredTargetConnected(value);
+            });
+        AzFramework::RemoteToolsInterface::Get()->RegisterRemoteToolsEndpointConnectedHandler(
+            LUADebugger::LuaToolsKey, m_connectedEventHandler);
+
+        m_changedEventHandler = AzFramework::RemoteToolsEndpointChangedEvent::Handler(
+            [this](AZ::u32 oldVal, AZ::u32 newVal)
+            {
+                this->DesiredTargetChanged(oldVal, newVal);
+            });
+        AzFramework::RemoteToolsInterface::Get()->RegisterRemoteToolsEndpointChangedHandler(
+            LUADebugger::LuaToolsKey, m_changedEventHandler);
     }
 
     void Context::Activate()
@@ -135,7 +152,6 @@ namespace LUAEditor
         Context_DebuggerManagement::Handler::BusConnect();
         LUABreakpointRequestMessages::Handler::BusConnect();
         LUAStackRequestMessages::Handler::BusConnect();
-        AzFramework::TargetManagerClient::Bus::Handler::BusConnect();
         LUAWatchesRequestMessages::Handler::BusConnect();
         LUATargetContextRequestMessages::Handler::BusConnect();
         HighlightedWords::Handler::BusConnect();
@@ -191,7 +207,6 @@ namespace LUAEditor
         Context_DebuggerManagement::Handler::BusDisconnect();
         LUAStackRequestMessages::Handler::BusDisconnect();
         LUABreakpointRequestMessages::Handler::BusDisconnect();
-        AzFramework::TargetManagerClient::Bus::Handler::BusDisconnect();
         HighlightedWords::Handler::BusDisconnect();
         AzFramework::AssetSystemInfoBus::Handler::BusDisconnect();
 

Code/Tools/LuaIDE/Source/LUA/LUAEditorContext.h

@@ -18,7 +18,6 @@
 #include "LUATargetContextTrackerMessages.h"
 #include "LUAWatchesDebuggerMessages.h"
 #include "LUAEditorContextMessages.h"
-#include "AzFramework/TargetManagement/TargetManagementAPI.h"
 #include "ClassReferencePanel.hxx"
 #include "LUAEditorMainWindow.hxx"
 #include "LUAEditorStyleMessages.h"
@@ -26,6 +25,7 @@
 #include <AzToolsFramework/UI/LegacyFramework/Core/EditorFrameworkAPI.h>
 #include <AzCore/Component/TickBus.h>
 #include <AzFramework/Asset/AssetSystemBus.h>
+#include <AzFramework/Network/IRemoteTools.h>
 #include <AzCore/Script/ScriptTimePoint.h>
 #include <QStandardItem>
 
@@ -63,7 +63,6 @@ namespace LUAEditor
         , private ContextInterface::Handler
         , private Context_DocumentManagement::Handler
         , private Context_DebuggerManagement::Handler
-        , private AzFramework::TargetManagerClient::Bus::Handler
         , private LUABreakpointRequestMessages::Handler
         , private LUAWatchesRequestMessages::Handler
         , private LUATargetContextRequestMessages::Handler
@@ -135,8 +134,8 @@ namespace LUAEditor
         //////////////////////////////////////////////////////////////////////////
         // Target Manager
         //////////////////////////////////////////////////////////////////////////
-        void DesiredTargetConnected(bool connected) override;
-        void DesiredTargetChanged(AZ::u32 newTargetID, AZ::u32 oldTargetID) override;
+        void DesiredTargetConnected(bool connected);
+        void DesiredTargetChanged(AZ::u32 newTargetID, AZ::u32 oldTargetID);
 
         //////////////////////////////////////////////////////////////////////////
         //Context_DebuggerManagement Messages
@@ -318,6 +317,9 @@ namespace LUAEditor
         AZ::IO::FileIOBase* m_fileIO;
 
         LegacyFramework::IPCHandleType m_ipcOpenFilesHandle;
+
+        AzFramework::RemoteToolsEndpointConnectedEvent::Handler m_connectedEventHandler;
+        AzFramework::RemoteToolsEndpointChangedEvent::Handler m_changedEventHandler;
     };
 
     class ReferenceItem

Code/Tools/LuaIDE/Source/LUA/LUAEditorContextMessages.h

@@ -14,7 +14,6 @@
 #include <AzCore/Script/ScriptContextDebug.h>
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzFramework/Script/ScriptRemoteDebugging.h>
-#include <AzFramework/TargetManagement/TargetManagementAPI.h>
 
 #pragma once
 

Code/Tools/LuaIDE/Source/LUA/LUAEditorMainWindow.cpp

@@ -39,6 +39,7 @@
 #include "LUAEditorContextMessages.h"
 #include "LUABreakpointTrackerMessages.h"
 #include "LUAEditorSettingsDialog.hxx"
+#include <Source/Utils/LuaIDEConstants.h>
 
 #include <Source/AssetDatabaseLocationListener.h>
 #include <Source/LUA/ui_LUAEditorMainWindow.h>
@@ -143,7 +144,7 @@ namespace LUAEditor
 
         this->setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
 
-        m_pTargetButton = aznew AzToolsFramework::TargetSelectorButtonAction(this);
+        m_pTargetButton = aznew AzToolsFramework::TargetSelectorButtonAction(LUADebugger::LuaToolsKey, this);
         m_gui->debugToolbar->addAction(m_pTargetButton);
         m_gui->menuDebug->addAction(m_pTargetButton);
 

Code/Tools/LuaIDE/Source/LUA/TargetContextButton.cpp

@@ -43,10 +43,6 @@ namespace LUA
 
     void TargetContextButton::DoPopup()
     {
-        AzFramework::TargetContainer targets;
-
-        EBUS_EVENT(AzFramework::TargetManager::Bus, EnumTargetInfos, targets);
-
         QMenu menu;
 
         AZStd::vector<AZStd::string> contexts;

Code/Tools/LuaIDE/Source/StandaloneToolsApplication.cpp

@@ -15,7 +15,6 @@
 #include <AzFramework/API/ApplicationAPI.h>
 #include <AzFramework/Asset/AssetCatalogComponent.h>
 #include <AzFramework/StringFunc/StringFunc.h>
-#include <AzFramework/TargetManagement/TargetManagementComponent.h>
 #include <AzNetworking/Framework/INetworkInterface.h>
 #include <AzNetworking/Framework/INetworking.h>
 #include <AzNetworking/Framework/NetworkingSystemComponent.h>
@@ -43,7 +42,6 @@ namespace StandaloneTools
         RegisterComponentDescriptor(AzNetworking::NetworkingSystemComponent::CreateDescriptor());
 
         RegisterComponentDescriptor(AZ::UserSettingsComponent::CreateDescriptor());
-        RegisterComponentDescriptor(AzFramework::TargetManagementComponent::CreateDescriptor());
 
         RegisterComponentDescriptor(AZ::JobManagerComponent::CreateDescriptor());
         RegisterComponentDescriptor(AZ::StreamerComponent::CreateDescriptor());
@@ -62,7 +60,7 @@ namespace StandaloneTools
         EnsureComponentCreated(AZ::StreamerComponent::RTTI_Type());
         EnsureComponentCreated(AZ::JobManagerComponent::RTTI_Type());
         EnsureComponentCreated(AzNetworking::NetworkingSystemComponent::RTTI_Type());
-        EnsureComponentCreated(AzFramework::TargetManagementComponent::RTTI_Type());
+        //EnsureComponentCreated(AzFramework::TargetManagementComponent::RTTI_Type());
         EnsureComponentCreated(LegacyFramework::IPCComponent::RTTI_Type());
 
         // Check for user settings components already added (added by the app descriptor
@@ -76,13 +74,14 @@ namespace StandaloneTools
             }
         }
 
+        /*
         AZ::ModuleManagerRequestBus::Broadcast(
             &AZ::ModuleManagerRequestBus::Events::EnumerateModules,
             [](const AZ::ModuleData& moduleData)
             {
                 AZ::Entity* moduleEntity = moduleData.GetEntity();
                 for (const auto& component : moduleEntity->GetComponents())
-                {
+                {                    
                     if (auto targetManagement = azrtti_cast<AzFramework::TargetManagementComponent*>(component))
                     {
                         targetManagement->SetTargetAsHost(true);
@@ -90,6 +89,7 @@ namespace StandaloneTools
                 }
                 return true;
             });
+            */
 
         // For each provider not already added, add it.
         for (AZ::u32 providerId = 0; providerId < userSettingsAdded.size(); ++providerId)
@@ -105,11 +105,11 @@ namespace StandaloneTools
     bool BaseApplication::StartDebugService()
     {
         AzNetworking::INetworkInterface* networkInterface =
-            AZ::Interface<AzNetworking::INetworking>::Get()->RetrieveNetworkInterface(AZ::Name("TargetManagement"));
+            AZ::Interface<AzNetworking::INetworking>::Get()->RetrieveNetworkInterface(AZ::Name("LuaRemoteTools"));
         if (networkInterface)
         {
             const auto console = AZ::Interface<AZ::IConsole>::Get();
-            uint16_t target_port = AzFramework::DefaultTargetPort;
+            uint16_t target_port = 0;//AzFramework::DefaultTargetPort;
 
             if (console->GetCvarValue("target_port", target_port) != AZ::GetValueResult::Success)
             {

Code/Tools/LuaIDE/Source/Utils/LuaIDEConstants.h

@@ -0,0 +1,16 @@
+/*
+ * 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/Name/Name.h>
+
+namespace LUADebugger
+{
+    static const AZ::Name LuaToolsName = AZ::Name("LuaRemoteTools");
+    static const AZ::Crc32 LuaToolsKey = AZ_CRC(LuaToolsName.GetCStr());
+}

Code/Tools/LuaIDE/lua_ide_files.cmake

@@ -76,4 +76,5 @@ set(FILES
     Source/LUA/CodeCompletion/LUACompleter.hxx
     Source/LUA/CodeCompletion/LUACompletionModel.cpp
     Source/LUA/CodeCompletion/LUACompletionModel.hxx
+    Source/Utils/LuaIDEConstants.h
 )

Gems/RemoteTools/Code/Source/RemoteToolsSystemComponent.cpp

@@ -94,17 +94,14 @@ namespace RemoteTools
 #endif
     }
 
-    AzFramework::RemoteToolsServiceKey RemoteToolsSystemComponent::RegisterToolingService(AZStd::string name, uint16_t port)
+    void RemoteToolsSystemComponent::RegisterToolingService(AZ::Crc32 key, AZ::Name name, uint16_t port)
     {
-        AzFramework::RemoteToolsServiceKey key = AZ::Crc32(name + AZStd::string::format("%d", port));
         m_entryRegistry[key] = RemoteToolsRegistryEntry();
         m_entryRegistry[key].m_name = name;
         m_entryRegistry[key].m_port = port;
-
-        return key;
     }
 
-    const AzFramework::ReceivedRemoteToolsMessages* RemoteToolsSystemComponent::GetReceivedMessages(AzFramework::RemoteToolsServiceKey key) const
+    const AzFramework::ReceivedRemoteToolsMessages* RemoteToolsSystemComponent::GetReceivedMessages(AZ::Crc32 key) const
     {
         if (m_inbox.contains(key))
         {
@@ -113,7 +110,7 @@ namespace RemoteTools
         return nullptr;
     }
 
-    void RemoteToolsSystemComponent::ClearReceivedMessages(AzFramework::RemoteToolsServiceKey key)
+    void RemoteToolsSystemComponent::ClearReceivedMessages(AZ::Crc32 key)
     {
         if (m_inbox.contains(key))
         {
@@ -122,30 +119,30 @@ namespace RemoteTools
     }
 
     void RemoteToolsSystemComponent::RegisterRemoteToolsEndpointJoinedHandler(
-        AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler)
+        AZ::Crc32 key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler)
     {
         handler.Connect(m_entryRegistry[key].m_endpointJoinedEvent);
     }
 
     void RemoteToolsSystemComponent::RegisterRemoteToolsEndpointLeftHandler(
-        AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler)
+        AZ::Crc32 key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler)
     {
         handler.Connect(m_entryRegistry[key].m_endpointLeftEvent);
     }
 
     void RemoteToolsSystemComponent::RegisterRemoteToolsEndpointConnectedHandler(
-        AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointConnectedEvent::Handler handler)
+        AZ::Crc32 key, AzFramework::RemoteToolsEndpointConnectedEvent::Handler handler)
     {
         handler.Connect(m_entryRegistry[key].m_endpointConnectedEvent);
     }
 
     void RemoteToolsSystemComponent::RegisterRemoteToolsEndpointChangedHandler(
-        AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointChangedEvent::Handler handler)
+        AZ::Crc32 key, AzFramework::RemoteToolsEndpointChangedEvent::Handler handler)
     {
         handler.Connect(m_entryRegistry[key].m_endpointChangedEvent);
     }
 
-    void RemoteToolsSystemComponent::EnumTargetInfos(AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointContainer& infos)
+    void RemoteToolsSystemComponent::EnumTargetInfos(AZ::Crc32 key, AzFramework::RemoteToolsEndpointContainer& infos)
     {
         if (m_entryRegistry.contains(key))
         {
@@ -157,7 +154,7 @@ namespace RemoteTools
         }
     }
 
-    void RemoteToolsSystemComponent::SetDesiredEndpoint(AzFramework::RemoteToolsServiceKey key, AZ::u32 desiredTargetID)
+    void RemoteToolsSystemComponent::SetDesiredEndpoint(AZ::Crc32 key, AZ::u32 desiredTargetID)
     {
         AZ_TracePrintf("RemoteToolsSystemComponent", "Set Target - %u", desiredTargetID);
         if (m_entryRegistry.contains(key))
@@ -186,12 +183,12 @@ namespace RemoteTools
         }
     }
 
-    void RemoteToolsSystemComponent::SetDesiredEndpointInfo(AzFramework::RemoteToolsServiceKey key, const AzFramework::RemoteToolsEndpointInfo& targetInfo)
+    void RemoteToolsSystemComponent::SetDesiredEndpointInfo(AZ::Crc32 key, const AzFramework::RemoteToolsEndpointInfo& targetInfo)
     {
         SetDesiredEndpoint(key, targetInfo.GetPersistentId());
     }
 
-    AzFramework::RemoteToolsEndpointInfo RemoteToolsSystemComponent::GetDesiredEndpoint(AzFramework::RemoteToolsServiceKey key)
+    AzFramework::RemoteToolsEndpointInfo RemoteToolsSystemComponent::GetDesiredEndpoint(AZ::Crc32 key)
     {
         if (m_entryRegistry.contains(key))
         {
@@ -201,7 +198,7 @@ namespace RemoteTools
         return AzFramework::RemoteToolsEndpointInfo(); // return an invalid target info.
     }
 
-    AzFramework::RemoteToolsEndpointInfo RemoteToolsSystemComponent::GetEndpointInfo(AzFramework::RemoteToolsServiceKey key, AZ::u32 desiredTargetID)
+    AzFramework::RemoteToolsEndpointInfo RemoteToolsSystemComponent::GetEndpointInfo(AZ::Crc32 key, AZ::u32 desiredTargetID)
     {
         if (m_entryRegistry.contains(key))
         {
@@ -216,7 +213,7 @@ namespace RemoteTools
         return AzFramework::RemoteToolsEndpointInfo(); // return an invalid target info.
     }
 
-    bool RemoteToolsSystemComponent::IsEndpointOnline(AzFramework::RemoteToolsServiceKey key, AZ::u32 desiredTargetID)
+    bool RemoteToolsSystemComponent::IsEndpointOnline(AZ::Crc32 key, AZ::u32 desiredTargetID)
     {
         if (m_entryRegistry.contains(key))
         {
@@ -303,7 +300,7 @@ namespace RemoteTools
         AzNetworking::ByteOrder byteOrder = connection->GetConnectionRole() == AzNetworking::ConnectionRole::Acceptor
             ? AzNetworking::ByteOrder::Host
             : AzNetworking::ByteOrder::Network;
-        AzFramework::RemoteToolsServiceKey key = connection->GetRemoteAddress().GetPort(byteOrder);
+        AZ::Crc32 key = connection->GetRemoteAddress().GetPort(byteOrder);
 
         if (m_entryRegistry.contains(key))
         {
@@ -322,7 +319,7 @@ namespace RemoteTools
         [[maybe_unused]] const AzNetworking::IPacketHeader& packetHeader,
         [[maybe_unused]] const RemoteToolsPackets::RemoteToolsPacket& packet)
     {
-        AzFramework::RemoteToolsServiceKey key = packet.GetPersistentId();
+        AZ::Crc32 key = packet.GetPersistentId();
 
         // Receive
         if (connection->GetConnectionRole() == AzNetworking::ConnectionRole::Acceptor

Gems/RemoteTools/Code/Source/RemoteToolsSystemComponent.h

@@ -25,7 +25,7 @@ namespace RemoteTools
 
     struct RemoteToolsRegistryEntry
     {
-        AZStd::string m_name;
+        AZ::Name m_name;
         uint16_t m_port;
 
         AzFramework::RemoteToolsEndpointContainer m_availableTargets;
@@ -106,31 +106,31 @@ namespace RemoteTools
         ////////////////////////////////////////////////////////////////////////
         // AzFramework::IRemoteTools interface implementation
 
-        AzFramework::RemoteToolsServiceKey RegisterToolingService(AZStd::string name, uint16_t port) override;
+        void RegisterToolingService(AZ::Crc32 key, AZ::Name name, uint16_t port) override;
 
-        const AzFramework::ReceivedRemoteToolsMessages* GetReceivedMessages(AzFramework::RemoteToolsServiceKey key) const override;
+        const AzFramework::ReceivedRemoteToolsMessages* GetReceivedMessages(AZ::Crc32 key) const override;
 
-        void ClearReceivedMessages(AzFramework::RemoteToolsServiceKey key) override;
+        void ClearReceivedMessages(AZ::Crc32 key) override;
 
-        void RegisterRemoteToolsEndpointJoinedHandler(AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler) override;
+        void RegisterRemoteToolsEndpointJoinedHandler(AZ::Crc32 key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler) override;
 
-        void RegisterRemoteToolsEndpointLeftHandler(AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler) override;
+        void RegisterRemoteToolsEndpointLeftHandler(AZ::Crc32 key, AzFramework::RemoteToolsEndpointStatusEvent::Handler handler) override;
 
-        void RegisterRemoteToolsEndpointConnectedHandler(AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointConnectedEvent::Handler handler) override;
+        void RegisterRemoteToolsEndpointConnectedHandler(AZ::Crc32 key, AzFramework::RemoteToolsEndpointConnectedEvent::Handler handler) override;
 
-        void RegisterRemoteToolsEndpointChangedHandler(AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointChangedEvent::Handler handler) override;
+        void RegisterRemoteToolsEndpointChangedHandler(AZ::Crc32 key, AzFramework::RemoteToolsEndpointChangedEvent::Handler handler) override;
 
-        void EnumTargetInfos(AzFramework::RemoteToolsServiceKey key, AzFramework::RemoteToolsEndpointContainer& infos) override;
+        void EnumTargetInfos(AZ::Crc32 key, AzFramework::RemoteToolsEndpointContainer& infos) override;
 
-        void SetDesiredEndpoint(AzFramework::RemoteToolsServiceKey key, AZ::u32 desiredTargetID) override;
+        void SetDesiredEndpoint(AZ::Crc32 key, AZ::u32 desiredTargetID) override;
 
-        void SetDesiredEndpointInfo(AzFramework::RemoteToolsServiceKey key, const AzFramework::RemoteToolsEndpointInfo& targetInfo) override;
+        void SetDesiredEndpointInfo(AZ::Crc32 key, const AzFramework::RemoteToolsEndpointInfo& targetInfo) override;
 
-        AzFramework::RemoteToolsEndpointInfo GetDesiredEndpoint(AzFramework::RemoteToolsServiceKey key) override;
+        AzFramework::RemoteToolsEndpointInfo GetDesiredEndpoint(AZ::Crc32 key) override;
 
-        AzFramework::RemoteToolsEndpointInfo GetEndpointInfo(AzFramework::RemoteToolsServiceKey key, AZ::u32 desiredTargetID) override;
+        AzFramework::RemoteToolsEndpointInfo GetEndpointInfo(AZ::Crc32 key, AZ::u32 desiredTargetID) override;
 
-        bool IsEndpointOnline(AzFramework::RemoteToolsServiceKey key, AZ::u32 desiredTargetID) override;
+        bool IsEndpointOnline(AZ::Crc32 key, AZ::u32 desiredTargetID) override;
 
         void SendRemoteToolsMessage(const AzFramework::RemoteToolsEndpointInfo& target, const AzFramework::RemoteToolsMessage& msg) override;
         ////////////////////////////////////////////////////////////////////////
@@ -138,9 +138,9 @@ namespace RemoteTools
         AZStd::unique_ptr<RemoteToolsJoinThread> m_joinThread;
         AZStd::unique_ptr<RemoteToolsOutboxThread> m_outboxThread;
 
-        AZStd::unordered_map<AzFramework::RemoteToolsServiceKey, RemoteToolsRegistryEntry> m_entryRegistry;
+        AZStd::unordered_map<AZ::Crc32, RemoteToolsRegistryEntry> m_entryRegistry;
 
-        AZStd::unordered_map<AzFramework::RemoteToolsServiceKey, AzFramework::ReceivedRemoteToolsMessages> m_inbox;
+        AZStd::unordered_map<AZ::Crc32, AzFramework::ReceivedRemoteToolsMessages> m_inbox;
         AZStd::mutex m_inboxMutex;
     };
 } // namespace RemoteTools