feat: adding RemoveListener and RemoveAllListeners to AddLateEvent (#764

) BREAKING CHANGE: AddLateEvent Reset no longer removes listeners
MirageNet · Apr 7, 2021 · 0ca2804 · 0ca2804
1 parent 360d59a
commit 0ca2804
Show file tree

Hide file tree

Showing 4 changed files with 108 additions and 29 deletions.
diff --git a/Assets/Mirage/Runtime/Events/AddLateEvent.cs b/Assets/Mirage/Runtime/Events/AddLateEvent.cs
@@ -84,6 +84,11 @@ public void AddListener(UnityAction handler)
             _event.AddListener(handler);
         }
 
+        public void RemoveListener(UnityAction handler)
+        {
+            _event.RemoveListener(handler);
+        }
+
         public void Invoke()
         {
             MarkInvoked();
@@ -119,6 +124,11 @@ public void AddListener(UnityAction<T0> handler)
             _event.AddListener(handler);
         }
 
+        public void RemoveListener(UnityAction<T0> handler)
+        {
+            _event.RemoveListener(handler);
+        }
+
         public void Invoke(T0 arg0)
         {
             MarkInvoked();
@@ -156,6 +166,11 @@ public void AddListener(UnityAction<T0, T1> handler)
             _event.AddListener(handler);
         }
 
+        public void RemoveListener(UnityAction<T0, T1> handler)
+        {
+            _event.RemoveListener(handler);
+        }
+
         public void Invoke(T0 arg0, T1 arg1)
         {
             MarkInvoked();

diff --git a/Assets/Mirage/Runtime/Events/AddLateEventBase.cs b/Assets/Mirage/Runtime/Events/AddLateEventBase.cs
@@ -13,11 +13,19 @@ protected void MarkInvoked()
         }
 
         /// <summary>
-        /// Resets event, removing all listens and allowing it to be invoked again
+        /// Resets invoked flag, meaning new handles wont be invoked untill invoke is called again
+        /// <para>Reset does not remove listeners</para>
         /// </summary>
         public void Reset()
         {
             hasInvoked = false;
+        }
+
+        /// <summary>
+        /// Remove all non-persisent (ie created from script) listeners from the event.
+        /// </summary>
+        public void RemoveAllListeners()
+        {
             baseEvent.RemoveAllListeners();
         }
     }

diff --git a/Assets/Mirage/Runtime/Events/IAddLateEvent.cs b/Assets/Mirage/Runtime/Events/IAddLateEvent.cs
@@ -11,6 +11,7 @@ namespace Mirage.Events
     public interface IAddLateEvent
     {
         void AddListener(UnityAction handler);
+        void RemoveListener(UnityAction handler);
     }
 
 
@@ -20,6 +21,7 @@ public interface IAddLateEvent
     public interface IAddLateEvent<T0>
     {
         void AddListener(UnityAction<T0> handler);
+        void RemoveListener(UnityAction<T0> handler);
     }
 
 
@@ -29,5 +31,6 @@ public interface IAddLateEvent<T0>
     public interface IAddLateEvent<T0, T1>
     {
         void AddListener(UnityAction<T0, T1> handler);
+        void RemoveListener(UnityAction<T0, T1> handler);
     }
 }
diff --git a/Assets/Tests/Editor/AddLateEventTests.cs b/Assets/Tests/Editor/AddLateEventTests.cs
@@ -1,5 +1,4 @@
 using NUnit.Framework;
-using NUnit.Framework.Internal;
 using UnityEngine.Events;
 
 namespace Mirage.Events.Tests
@@ -12,7 +11,9 @@ public abstract class AddLateEventTestsBase
         protected abstract void Init();
         protected abstract void Invoke();
         protected abstract void AddListener();
+        protected abstract void RemoveListener();
         protected abstract void Reset();
+        protected abstract void RemoveAllListeners();
 
 
         [SetUp]
@@ -30,7 +31,6 @@ public void EventCanBeInvokedOnce()
             Assert.That(listenerCallCount, Is.EqualTo(1));
         }
 
-
         [Test]
         public void EventCanBeInvokedTwice()
         {
@@ -99,18 +99,32 @@ public void ResetThenAddListenerDoesntInvokeRightAway()
             Assert.That(listenerCallCount, Is.EqualTo(1), "Event should not auto invoke after reset");
 
             Invoke();
-            Assert.That(listenerCallCount, Is.EqualTo(2));
+            Assert.That(listenerCallCount, Is.EqualTo(3), "old and new listeners should have been invoked");
         }
 
         [Test]
-        public void ResetEventRemovesOldListners()
+        public void RemoveListenersShouldRemove1Listner()
         {
             AddListener();
 
             Invoke();
             Assert.That(listenerCallCount, Is.EqualTo(1));
 
-            Reset();
+            RemoveListener();
+            Invoke();
+            // listener removed so no increase to count
+            Assert.That(listenerCallCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void RemoveAllRemovesListeners()
+        {
+            AddListener();
+
+            Invoke();
+            Assert.That(listenerCallCount, Is.EqualTo(1));
+
+            RemoveAllListeners();
 
             Assert.DoesNotThrow(() =>
             {
@@ -124,25 +138,35 @@ public void ResetEventRemovesOldListners()
 
     public class AddLateEvent0ArgTest : AddLateEventTestsBase
     {
-        AddLateEvent onceEvent;
+        AddLateEvent allLate;
         protected override void Init()
         {
-            onceEvent = new AddLateEvent();
+            allLate = new AddLateEvent();
         }
 
         protected override void Invoke()
         {
-            onceEvent.Invoke();
+            allLate.Invoke();
         }
 
         protected override void AddListener()
         {
-            onceEvent.AddListener(TestListener);
+            allLate.AddListener(TestListener);
+        }
+
+        protected override void RemoveListener()
+        {
+            allLate.RemoveListener(TestListener);
         }
 
         protected override void Reset()
         {
-            onceEvent.Reset();
+            allLate.Reset();
+        }
+
+        protected override void RemoveAllListeners()
+        {
+            allLate.RemoveAllListeners();
         }
     }
 
@@ -151,26 +175,41 @@ public class IntUnityEvent : UnityEvent<int> { }
     public class IntAddLateEvent : AddLateEvent<int, IntUnityEvent> { }
     public class AddLateEvent1ArgTest : AddLateEventTestsBase
     {
-        IntAddLateEvent onceEvent;
+        IntAddLateEvent allLate;
+
+        void TestListener1Arg(int a)
+        {
+            TestListener();
+        }
 
         protected override void Init()
         {
-            onceEvent = new IntAddLateEvent();
+            allLate = new IntAddLateEvent();
         }
 
         protected override void Invoke()
         {
-            onceEvent.Invoke(default);
+            allLate.Invoke(default);
         }
 
         protected override void AddListener()
         {
-            onceEvent.AddListener((_) => TestListener());
+            allLate.AddListener(TestListener1Arg);
+        }
+
+        protected override void RemoveListener()
+        {
+            allLate.RemoveListener(TestListener1Arg);
         }
 
         protected override void Reset()
         {
-            onceEvent.Reset();
+            allLate.Reset();
+        }
+
+        protected override void RemoveAllListeners()
+        {
+            allLate.RemoveAllListeners();
         }
 
         [Test]
@@ -180,14 +219,14 @@ public void ListenerIsInvokedWithCorrectArgs()
 
             int callCount = 0;
 
-            onceEvent.AddListener((a0) =>
+            allLate.AddListener((a0) =>
             {
                 callCount++;
                 Assert.That(a0, Is.EqualTo(arg0));
             });
 
 
-            onceEvent.Invoke(arg0);
+            allLate.Invoke(arg0);
             Assert.That(callCount, Is.EqualTo(1));
         }
 
@@ -199,9 +238,9 @@ public void ListenerIsInvokedLateWithCorrectArgs()
             int callCount = 0;
 
             // invoke before adding handler
-            onceEvent.Invoke(arg0);
+            allLate.Invoke(arg0);
 
-            onceEvent.AddListener((a0) =>
+            allLate.AddListener((a0) =>
             {
                 callCount++;
                 Assert.That(a0, Is.EqualTo(arg0));
@@ -216,26 +255,40 @@ public class IntStringUnityEvent : UnityEvent<int, string> { }
     public class IntStringAddLateEvent : AddLateEvent<int, string, IntStringUnityEvent> { }
     public class AddLateEvent2ArgTest : AddLateEventTestsBase
     {
-        IntStringAddLateEvent onceEvent;
+        IntStringAddLateEvent allLate;
+        void TestListener2Arg(int a, string b)
+        {
+            TestListener();
+        }
 
         protected override void Init()
         {
-            onceEvent = new IntStringAddLateEvent();
+            allLate = new IntStringAddLateEvent();
         }
 
         protected override void Invoke()
         {
-            onceEvent.Invoke(default, default);
+            allLate.Invoke(default, default);
         }
 
         protected override void AddListener()
         {
-            onceEvent.AddListener((_, __) => TestListener());
+            allLate.AddListener(TestListener2Arg);
+        }
+
+        protected override void RemoveListener()
+        {
+            allLate.RemoveListener(TestListener2Arg);
         }
 
         protected override void Reset()
         {
-            onceEvent.Reset();
+            allLate.Reset();
+        }
+
+        protected override void RemoveAllListeners()
+        {
+            allLate.RemoveAllListeners();
         }
 
         [Test]
@@ -246,15 +299,15 @@ public void ListenerIsInvokedWithCorrectArgs()
 
             int callCount = 0;
 
-            onceEvent.AddListener((a0, a1) =>
+            allLate.AddListener((a0, a1) =>
             {
                 callCount++;
                 Assert.That(a0, Is.EqualTo(arg0));
                 Assert.That(a1, Is.EqualTo(arg1));
             });
 
 
-            onceEvent.Invoke(arg0, arg1);
+            allLate.Invoke(arg0, arg1);
             Assert.That(callCount, Is.EqualTo(1));
         }
 
@@ -267,9 +320,9 @@ public void ListenerIsInvokedLateWithCorrectArgs()
             int callCount = 0;
 
             // invoke before adding handler
-            onceEvent.Invoke(arg0, arg1);
+            allLate.Invoke(arg0, arg1);
 
-            onceEvent.AddListener((a0, a1) =>
+            allLate.AddListener((a0, a1) =>
             {
                 callCount++;
                 Assert.That(a0, Is.EqualTo(arg0));