com.wallstop-studios.dxmessaging 2.0.0 → 2.1.0

package/Runtime/Unity/MessageBusProviderHandle.cs

@@ -0,0 +1,97 @@
+namespace DxMessaging.Unity
+{
+    using System;
+    using DxMessaging.Core.MessageBus;
+    using UnityEngine;
+    using UnityEngine.Serialization;
+
+    /// <summary>
+    /// Serializable handle that references a <see cref="ScriptableMessageBusProvider"/> or runtime provider.
+    /// </summary>
+    [Serializable]
+    public struct MessageBusProviderHandle
+    {
+        [FormerlySerializedAs("providerAsset")]
+        [SerializeField]
+        private ScriptableMessageBusProvider _provider;
+
+        [NonSerialized]
+        private IMessageBusProvider _runtimeProvider;
+
+        /// <summary>
+        /// Initializes a new instance referencing the supplied provider asset.
+        /// </summary>
+        /// <param name="provider">Serialized provider asset.</param>
+        public MessageBusProviderHandle(ScriptableMessageBusProvider provider)
+        {
+            _provider = provider;
+            _runtimeProvider = provider;
+        }
+
+        /// <summary>
+        /// Gets an empty handle.
+        /// </summary>
+        public static MessageBusProviderHandle Empty => default;
+
+        /// <summary>
+        /// Creates a handle that wraps a runtime-only provider instance.
+        /// </summary>
+        /// <param name="provider">Runtime provider.</param>
+        /// <returns>Handle referencing the provider.</returns>
+        public static MessageBusProviderHandle FromProvider(IMessageBusProvider provider)
+        {
+            MessageBusProviderHandle handle = default;
+            handle._runtimeProvider = provider;
+            return handle;
+        }
+
+        /// <summary>
+        /// Associates the handle with a runtime provider, returning a new handle.
+        /// </summary>
+        /// <param name="provider">Provider to associate.</param>
+        /// <returns>New handle referencing the provider.</returns>
+        public MessageBusProviderHandle WithRuntimeProvider(IMessageBusProvider provider)
+        {
+            MessageBusProviderHandle handle = this;
+            handle._runtimeProvider = provider;
+            return handle;
+        }
+
+        /// <summary>
+        /// Attempts to resolve the provider referenced by this handle.
+        /// </summary>
+        /// <param name="provider">Resolved provider.</param>
+        /// <returns><c>true</c> when a provider exists; otherwise <c>false</c>.</returns>
+        public bool TryGetProvider(out IMessageBusProvider provider)
+        {
+            if (_runtimeProvider != null)
+            {
+                provider = _runtimeProvider;
+                return true;
+            }
+
+            if (_provider != null)
+            {
+                provider = _provider;
+                return true;
+            }
+
+            provider = null;
+            return false;
+        }
+
+        /// <summary>
+        /// Resolves the effective message bus for this handle.
+        /// </summary>
+        /// <returns>The resolved bus, or <see langword="null"/> if none available.</returns>
+        public IMessageBus ResolveBus()
+        {
+            if (!TryGetProvider(out IMessageBusProvider provider))
+            {
+                return null;
+            }
+
+            return provider.Resolve();
+        }
+    }
+}

package/Runtime/Unity/MessageBusProviderHandle.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6c23b0c0c26d4bafbf0036ad36345a63
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

package/Runtime/Unity/MessagingComponent.cs

@@ -3,6 +3,7 @@ namespace DxMessaging.Unity
     using System;
     using System.Collections.Generic;
     using Core;
+    using Core.MessageBus;
     using UnityEngine;
     using UnityEngine.Serialization;
 
@@ -26,11 +27,37 @@ namespace DxMessaging.Unity
         [FormerlySerializedAs("_emitMessagesWhenDisabled")]
         public bool emitMessagesWhenDisabled;
 
+        [SerializeField]
+        private bool autoConfigureSerializedProviderOnAwake;
+
+        [SerializeField]
+        private MessageBusProviderHandle _serializedProviderHandle;
+
         private MessageHandler _messageHandler;
 
+        [NonSerialized]
+        private IMessageBus _messageBusOverride;
+
+        [NonSerialized]
+        private IMessageBusProvider _messageBusProvider;
+
         internal readonly Dictionary<MonoBehaviour, MessageRegistrationToken> _registeredListeners =
             new();
 
+        /// <summary>
+        /// Creates a <see cref="IMessageRegistrationBuilder"/> aligned with this component's configured bus or provider.
+        /// </summary>
+        public IMessageRegistrationBuilder CreateRegistrationBuilder()
+        {
+            IMessageBusProvider provider = ResolveRegistrationProvider();
+            if (provider != null)
+            {
+                return new MessageRegistrationBuilder(provider);
+            }
+
+            return new MessageRegistrationBuilder();
+        }
+
         /// <summary>
         /// Creates (or returns existing) registration token for the given component on this GameObject.
         /// </summary>
@@ -73,6 +100,66 @@ namespace DxMessaging.Unity
             return createdToken;
         }
 
+        /// <summary>
+        /// Overrides the default message bus used when new handlers are created.
+        /// </summary>
+        /// <param name="messageBus">Message bus to prefer. Pass <c>null</c> to fall back to the global bus.</param>
+        /// <param name="rebindMode">Controls whether existing registrations move to the new bus immediately.</param>
+        public void Configure(IMessageBus messageBus, MessageBusRebindMode rebindMode)
+        {
+            _messageBusOverride = messageBus;
+            _messageBusProvider = null;
+            _serializedProviderHandle = MessageBusProviderHandle.Empty;
+            ApplyMessageBusConfiguration(rebindMode);
+        }
+
+        /// <summary>
+        /// Configures the component to resolve message buses via the supplied provider.
+        /// </summary>
+        /// <param name="messageBusProvider">Provider to use for subsequent handler/token resolution.</param>
+        /// <param name="rebindMode">Controls whether existing listeners should migrate immediately.</param>
+        public void Configure(
+            IMessageBusProvider messageBusProvider,
+            MessageBusRebindMode rebindMode
+        )
+        {
+            _messageBusProvider = messageBusProvider;
+            if (messageBusProvider != null)
+            {
+                _messageBusOverride = null;
+            }
+
+            _serializedProviderHandle =
+                messageBusProvider != null
+                    ? MessageBusProviderHandle.FromProvider(messageBusProvider)
+                    : MessageBusProviderHandle.Empty;
+            ApplyMessageBusConfiguration(rebindMode);
+        }
+
+        /// <summary>
+        /// Configures the component using a serialized provider handle.
+        /// </summary>
+        /// <param name="providerHandle">Handle that resolves the preferred provider.</param>
+        /// <param name="rebindMode">Controls whether existing listeners should migrate immediately.</param>
+        public void Configure(
+            MessageBusProviderHandle providerHandle,
+            MessageBusRebindMode rebindMode
+        )
+        {
+            _serializedProviderHandle = providerHandle;
+            if (providerHandle.TryGetProvider(out IMessageBusProvider provider))
+            {
+                _messageBusProvider = provider;
+                _messageBusOverride = null;
+            }
+            else
+            {
+                _messageBusProvider = null;
+            }
+
+            ApplyMessageBusConfiguration(rebindMode);
+        }
+
         /// <summary>
         /// Releases the registration token previously created for <paramref name="listener"/>.
         /// </summary>
@@ -83,7 +170,7 @@ namespace DxMessaging.Unity
         /// </remarks>
         public bool Release(MonoBehaviour listener)
         {
-            if (listener is null)
+            if (listener == null)
             {
                 return false;
             }
@@ -102,6 +189,16 @@ namespace DxMessaging.Unity
         /// </summary>
         private void Awake()
         {
+            if (
+                autoConfigureSerializedProviderOnAwake
+                && _messageBusOverride == null
+                && _messageBusProvider == null
+                && _serializedProviderHandle.TryGetProvider(out IMessageBusProvider provider)
+            )
+            {
+                _messageBusProvider = provider;
+            }
+
             _messageHandler ??= CreateMessageHandler();
         }
 
@@ -143,7 +240,72 @@ namespace DxMessaging.Unity
         /// </summary>
         private MessageHandler CreateMessageHandler()
         {
-            return new MessageHandler(gameObject) { active = true };
+            IMessageBus resolvedBus = ResolveConfiguredBus();
+            MessageHandler handler = new(gameObject, resolvedBus) { active = true };
+            return handler;
+        }
+
+        private void ApplyMessageBusConfiguration(MessageBusRebindMode rebindMode)
+        {
+            IMessageBus resolvedBus = ResolveConfiguredBus();
+            _messageHandler?.SetDefaultMessageBus(resolvedBus);
+            if (_registeredListeners.Count == 0)
+            {
+                return;
+            }
+
+            MessageBusRebindMode effectiveMode =
+#pragma warning disable CS0618 // Type or member is obsolete
+                rebindMode == MessageBusRebindMode.Unknown
+#pragma warning restore CS0618 // Type or member is obsolete
+                    ? MessageBusRebindMode.RebindActive
+                    : rebindMode;
+
+            foreach (MessageRegistrationToken token in _registeredListeners.Values)
+            {
+                token.RetargetMessageBus(resolvedBus, effectiveMode);
+            }
+        }
+
+        private IMessageBus ResolveConfiguredBus()
+        {
+            if (_messageBusOverride != null)
+            {
+                return _messageBusOverride;
+            }
+
+            if (_messageBusProvider != null)
+            {
+                IMessageBus providedBus = _messageBusProvider.Resolve();
+                if (providedBus != null)
+                {
+                    return providedBus;
+                }
+            }
+
+            return null;
+        }
+
+        private IMessageBusProvider ResolveRegistrationProvider()
+        {
+            if (_messageBusProvider != null)
+            {
+                return _messageBusProvider;
+            }
+
+            if (
+                _serializedProviderHandle.TryGetProvider(out IMessageBusProvider providerFromHandle)
+            )
+            {
+                return providerFromHandle;
+            }
+
+            if (_messageBusOverride != null)
+            {
+                return new FixedMessageBusProvider(_messageBusOverride);
+            }
+
+            return null;
         }
     }
 }

package/Runtime/Unity/MessagingComponentInstaller.cs

@@ -0,0 +1,120 @@
+namespace DxMessaging.Unity
+{
+    using System.Collections.Generic;
+    using Core.MessageBus;
+    using UnityEngine;
+
+    /// <summary>
+    /// Applies a shared message bus or provider to <see cref="MessagingComponent"/> instances in the hierarchy.
+    /// </summary>
+    [DisallowMultipleComponent]
+    public sealed class MessagingComponentInstaller : MonoBehaviour
+    {
+        [SerializeField]
+        private bool applyOnAwake = true;
+
+        [SerializeField]
+        private bool includeInactive = true;
+
+        [SerializeField]
+        private MessageBusProviderHandle providerHandle;
+
+        [SerializeReference]
+        private IMessageBus explicitMessageBus;
+
+        private readonly List<MessagingComponent> _messagingComponents = new();
+
+        private void Awake()
+        {
+            if (applyOnAwake)
+            {
+                ApplyConfiguration();
+            }
+        }
+
+        /// <summary>
+        /// Applies the configured bus or provider to all <see cref="MessagingComponent"/> descendants.
+        /// </summary>
+        public void ApplyConfiguration()
+        {
+            GetComponentsInChildren<MessagingComponent>(includeInactive, _messagingComponents);
+
+            if (_messagingComponents.Count == 0)
+            {
+                return;
+            }
+
+            if (providerHandle.TryGetProvider(out IMessageBusProvider provider))
+            {
+                foreach (MessagingComponent component in _messagingComponents)
+                {
+                    component.Configure(providerHandle, MessageBusRebindMode.RebindActive);
+                }
+
+                return;
+            }
+
+            if (explicitMessageBus != null)
+            {
+                foreach (MessagingComponent component in _messagingComponents)
+                {
+                    component.Configure(explicitMessageBus, MessageBusRebindMode.RebindActive);
+                }
+
+                return;
+            }
+
+            Debug.LogWarning(
+                $"{nameof(MessagingComponentInstaller)} on {name} has no provider or explicit message bus configured.",
+                this
+            );
+        }
+
+        /// <summary>
+        /// Creates a registration builder that mirrors the installer configuration.
+        /// </summary>
+        public IMessageRegistrationBuilder CreateRegistrationBuilder()
+        {
+            IMessageBusProvider provider = ResolveEffectiveProvider();
+            if (provider != null)
+            {
+                return new MessageRegistrationBuilder(provider);
+            }
+
+            if (explicitMessageBus != null)
+            {
+                return new MessageRegistrationBuilder(
+                    new FixedMessageBusProvider(explicitMessageBus)
+                );
+            }
+
+            return new MessageRegistrationBuilder();
+        }
+
+        /// <summary>
+        /// Assigns the provider handle that will be used for subsequent applications.
+        /// </summary>
+        public void SetProvider(MessageBusProviderHandle handle)
+        {
+            providerHandle = handle;
+        }
+
+        /// <summary>
+        /// Assigns an explicit message bus that overrides the provider handle when present.
+        /// </summary>
+        public void SetExplicitMessageBus(IMessageBus messageBus)
+        {
+            explicitMessageBus = messageBus;
+        }
+
+        private IMessageBusProvider ResolveEffectiveProvider()
+        {
+            if (providerHandle.TryGetProvider(out IMessageBusProvider provider))
+            {
+                return provider;
+            }
+
+            return null;
+        }
+    }
+}

package/Runtime/Unity/MessagingComponentInstaller.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3a28d2b5a3c74e44b922cb972782f7d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

package/Runtime/Unity/ScriptableMessageBusProvider.cs

@@ -0,0 +1,14 @@
+namespace DxMessaging.Unity
+{
+    using DxMessaging.Core.MessageBus;
+    using UnityEngine;
+
+    /// <summary>
+    /// Base <see cref="ScriptableObject"/> that resolves an <see cref="IMessageBus"/> instance.
+    /// </summary>
+    public abstract class ScriptableMessageBusProvider : ScriptableObject, IMessageBusProvider
+    {
+        /// <inheritdoc />
+        public abstract IMessageBus Resolve();
+    }
+}

package/Runtime/Unity/ScriptableMessageBusProvider.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9a0b0701f2dbb8946b7bc27f68c1cc55
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

package/Samples~/DI/Prefabs/MessagingInstallerSample.prefab

@@ -0,0 +1,98 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &100000
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 400000}
+  - component: {fileID: 11400000}
+  m_Layer: 0
+  m_Name: MessagingInstallerSample
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &400000
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 100000}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 400001}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 100000}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 3a28d2b5a3c74e44b922cb972782f7d1, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  applyOnAwake: 1
+  includeInactive: 1
+  providerHandle:
+    providerAsset: {fileID: 11400000, guid: a4f3a0b76ff44160a7453a58aa654a3a, type: 2}
+  explicitMessageBus: {}
+--- !u!1 &100001
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 400001}
+  - component: {fileID: 11400001}
+  m_Layer: 0
+  m_Name: MessagingListener
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &400001
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 100001}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 400000}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &11400001
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 100001}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 98ea04ea326660845ba49942dacbf907, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  emitMessagesWhenDisabled: 0
+  autoConfigureSerializedProviderOnAwake: 0
+  _serializedProviderHandle:
+    providerAsset: {fileID: 0}

package/Samples~/DI/Prefabs/MessagingInstallerSample.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2d5f318e8b9a4a559ef886795bc8a1dd
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/DI/Prefabs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e4e0e7c97cb24f4fa4a8718f2768e8c4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/DI/Providers/GlobalMessageBusProvider.asset

@@ -0,0 +1,14 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 689f1e1a8d9f4c34f9e3ab4e3f94ec37, type: 3}
+  m_Name: GlobalMessageBusProvider
+  m_EditorClassIdentifier: 

package/Samples~/DI/Providers/GlobalMessageBusProvider.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a4f3a0b76ff44160a7453a58aa654a3a
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/DI/Providers/InitialGlobalMessageBusProvider.asset

@@ -0,0 +1,14 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 1f3f2efbb7f4441ebde8b418d178885a, type: 3}
+  m_Name: InitialGlobalMessageBusProvider
+  m_EditorClassIdentifier: 

package/Samples~/DI/Providers/InitialGlobalMessageBusProvider.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9224435f740044bebddcdabe6a8ecc87
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Samples~/DI/Providers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6b1ab34b9b8c4886ab4e6a5f5c23af62
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: