First Public Release of Event Framework

Introducing the first release of Event Framework - including Messenger for managing subscribers, publishing Payloads (events) and getting current statuses.

Author: PlayDevX

DevsDaddy/Shared/EventFramework/Core.meta

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+
+namespace DevsDaddy.Shared.EventFramework.Core.Extensions
+{
+    public static class CollectionExtensions
+    {
+        public static object[] ToObjectArray<T>(this T[] source)
+        {
+            if(source.IsNullOrEmpty())
+            {
+                return null;
+            }
+            var copy = new object[source.Length];
+            Array.Copy(source, copy, source.Length);
+            return copy;
+        }
+        
+        public static bool IsNullOrEmpty<T>(this ICollection<T> source)
+        {
+            if(source == null)
+            {
+                return true;
+            }
+            if(source.Count < 1)
+            {
+                return true;
+            }
+            return false;
+        }
+        
+        public static void ForEach<T>(this IEnumerable<T> collection, Action<T> action)
+        {
+            foreach (var item in collection)
+            {
+                action(item);
+            }
+        }
+        
+        public static bool IsNullOrEmpty(this string source)
+        {
+            var isEmpty = string.IsNullOrEmpty(source);
+            return isEmpty;
+        }
+    }
+}

DevsDaddy/Shared/EventFramework/Core/Extensions.meta

@@ -0,0 +1,164 @@
+using System;
+using System.Reflection;
+using UnityEngine;
+
+namespace DevsDaddy.Shared.EventFramework.Core.Messenger
+{
+    /// <summary>
+    /// Event Subscriber Class
+    /// </summary>
+    internal class EventSubscriber : IDisposable
+    {
+        private WeakReference _callbackTarget;
+        private MethodInfo _callbackMethod;
+        
+        private WeakReference _predicateTarget;
+        private MethodInfo _predicateMethod;
+        
+        public bool IsAlive
+        {
+            get
+            {
+                if(_callbackMethod == null)
+                {
+                    return false;
+                }
+                if(_callbackMethod.IsStatic)
+                {
+                    return true;
+                }
+                if(_callbackTarget == null ||
+                   !_callbackTarget.IsAlive ||
+                   _callbackTarget.Target == null)
+                {
+                    return false;
+                }
+                return true;
+            }
+        }
+        
+        public Type PayloadType
+        {
+            get;
+        }
+        
+        public int Id 
+        {
+            get;
+        }
+
+        public override int GetHashCode()
+        {
+            return Id;
+        }
+        
+        public EventSubscriber(Type payloadType, Delegate callback, Delegate predicate = null)
+        {
+            // validate params
+            if(payloadType == null)
+            {
+                throw new ArgumentNullException(nameof(payloadType));
+            }
+            if(callback == null)
+            {
+                throw new ArgumentNullException(nameof(callback));
+            }
+            
+            // assign values to vars
+            PayloadType = payloadType;
+            Id = callback.GetHashCode();
+            _callbackMethod = callback.Method;
+
+            // check if callback method is not a static method
+            if(!_callbackMethod.IsStatic && 
+               callback.Target != null)
+            {
+                // init weak reference to callback owner
+                _callbackTarget = new WeakReference(callback.Target);
+            }
+            
+            // --- init predicate ---
+            if(predicate == null)
+            {
+                return;
+            }            
+            _predicateMethod = predicate.Method;
+
+            if(!_predicateMethod.IsStatic && 
+               !Equals(predicate.Target, callback.Target))
+            {
+                _predicateTarget = new WeakReference(predicate.Target);
+            }                     
+        }
+        
+        public void Invoke<T>(T payload)
+        {
+            // validate callback method info
+            if(_callbackMethod == null)
+            {
+                Debug.LogError($"{nameof(_callbackMethod)} is null.");
+                return;
+            }
+            if(!_callbackMethod.IsStatic && 
+               (_callbackTarget == null || 
+                !_callbackTarget.IsAlive))
+            {
+                Debug.LogWarning($"{nameof(_callbackMethod)} is not alive.");
+                return;
+            }
+
+            // get reference to the predicate function owner
+            if(_predicateMethod != null)
+            {
+                object predicateTarget = null;
+                if(!_predicateMethod.IsStatic)
+                {
+                    if(_predicateTarget != null && 
+                       _predicateTarget.IsAlive)
+                    {
+                        predicateTarget = _predicateTarget.Target;
+                    }
+                    else if(_callbackTarget != null && 
+                            _callbackTarget.IsAlive)
+                    {
+                        predicateTarget = _callbackTarget.Target;
+                    }
+                }
+
+                // check if predicate returned 'true'
+                var isAccepted = (bool)_predicateMethod.Invoke(predicateTarget, new object[] {payload});
+                if(!isAccepted)
+                {
+                    // TODO log ?
+                    return;
+                }
+            }
+
+            // invoke callback method
+            object callbackTarget = null;
+            if(!_callbackMethod.IsStatic && 
+               _callbackTarget != null && _callbackTarget.IsAlive)
+            {
+                callbackTarget = _callbackTarget.Target;
+            }
+            _callbackMethod.Invoke(callbackTarget, new object[] {payload});
+        }
+        
+        public void Dispose()
+        {
+            _callbackMethod = null;
+            if(_callbackTarget != null)
+            {             
+                _callbackTarget.Target = null;
+                _callbackTarget = null;
+            }
+            
+            _predicateMethod = null;
+            if(_predicateTarget != null)
+            {
+                _predicateTarget.Target = null;
+                _predicateTarget = null;
+            }
+        }
+    }
+}

DevsDaddy/Shared/EventFramework/Core/Extensions/CollectionExtensions.cs

@@ -0,0 +1,7 @@
+namespace DevsDaddy.Shared.EventFramework.Core.Messenger
+{
+    /// <summary>
+    /// Event Messenger Interface
+    /// </summary>
+    public interface IEventMessenger : IEventMessengerPublish, IEventMessengerSubscribe, IEventMessengerUnsubscribe { }
+}

DevsDaddy/Shared/EventFramework/Core/Extensions/CollectionExtensions.cs.meta

@@ -0,0 +1,25 @@
+using DevsDaddy.Shared.EventFramework.Core.Payloads;
+
+namespace DevsDaddy.Shared.EventFramework.Core.Messenger
+{
+    /// <summary>
+    /// Event Messenger Publish Interface
+    /// </summary>
+    public interface IEventMessengerPublish
+    {
+        /// <summary>
+        /// Publish Payload
+        /// </summary>
+        /// <param name="payload"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        IEventMessengerPublish Publish<T>(T payload) where T : IPayload;
+
+        /// <summary>
+        /// Get Current Payload State or Null
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        T GetState<T>() where T : class, IPayload;
+    }
+}