Merge pull request #116 from WalletConnect/feat/dispose-modules

Allow modules to be disposed

Core Modules/WalletConnectSharp.Common/IModule.cs

@@ -5,7 +5,7 @@ namespace WalletConnectSharp.Common
     /// <summary>
     /// An interface that represents a module
     /// </summary>
-    public interface IModule /* : IDisposable */
+    public interface IModule : IDisposable
     {
         /// <summary>
         /// The name of this module
@@ -18,4 +18,4 @@ public interface IModule /* : IDisposable */
         /// </summary>
         string Context { get; }
     }
-}
+}

Core Modules/WalletConnectSharp.Common/Model/IsolatedModule.cs

@@ -38,5 +38,7 @@ public IsolatedModule()
 
             activeModules.Add(_guid);
         }
+
+        public void Dispose() { }
     }
-}
+}

Core Modules/WalletConnectSharp.Crypto/Crypto.cs

@@ -684,5 +684,10 @@ private async Task<byte[]> GetClientSeed()
 
             return seed.HexToByteArray();
         }
+
+        public void Dispose()
+        {
+            KeyChain?.Dispose();
+        }
     }
 }

Core Modules/WalletConnectSharp.Crypto/KeyChain.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Threading.Tasks;
-using WalletConnectSharp.Common;
 using WalletConnectSharp.Common.Model.Errors;
 using WalletConnectSharp.Common.Utils;
 using WalletConnectSharp.Crypto.Interfaces;
@@ -199,5 +195,11 @@ private async Task SaveKeyChain()
         {
             await Storage.SetItem(StorageKey, this._keyChain);
         }
+
+        public void Dispose()
+        {
+            _keyChain?.Clear();
+            Storage?.Dispose();
+        }
     }
 }

Core Modules/WalletConnectSharp.Events/EventDelegator.cs

@@ -20,6 +20,7 @@ namespace WalletConnectSharp.Events
     /// </summary>
     public class EventDelegator : IModule
     {
+        private static readonly object _contextLock = new object();
         private static HashSet<string> contextInstances = new HashSet<string>();
 
         private readonly object _cacheLock = new object();
@@ -47,11 +48,14 @@ public EventDelegator(IModule parent)
             this.Name = parent + ":event-delegator";
             this.Context = parent.Context;
 
-            if (contextInstances.Contains(Context))
-                throw new ArgumentException(
-                    $"The module {parent.Name} with context {Context} is attempting to create a new EventDelegator that overlaps with an existing EventDelegator");
-
-            contextInstances.Add(Context);
+            lock (_contextLock)
+            {
+                if (contextInstances.Contains(Context))
+                    throw new ArgumentException(
+                        $"The module {parent.Name} with context {Context} is attempting to create a new EventDelegator that overlaps with an existing EventDelegator");
+
+                contextInstances.Add(Context);
+            }
         }
 
         /// <summary>
@@ -243,5 +247,47 @@ from type in assembly.GetTypes()
 
             return wasTriggered;
         }
+
+        public void Dispose()
+        {
+            lock (_cacheLock)
+            {
+                // loop through all cached types and remove all listeners
+                foreach (var eventType in _typeToTriggerTypes.Keys)
+                {
+                    var allPossibleTypes = _typeToTriggerTypes[eventType];
+
+                    // loop through all possible types of an event type, since
+                    // event listeners can be anywhere
+                    foreach (var type in allPossibleTypes)
+                    {
+                        var genericFactoryType = typeof(EventFactory<>).MakeGenericType(type);
+
+                        var instanceProperty = genericFactoryType.GetMethod("InstanceOf");
+                        if (instanceProperty == null) continue;
+
+                        var genericFactory = instanceProperty.Invoke(null, new object[] { Context });
+
+                        var genericProviderProperty = genericFactoryType.GetProperty("Provider");
+                        if (genericProviderProperty == null) continue;
+
+                        var genericProvider = genericProviderProperty.GetValue(genericFactory);
+                        if (genericProvider == null) continue;
+
+                        // type of IEventProvider is IDisposable
+                        IDisposable disposable = (IDisposable)genericProvider;
+
+                        // dispose of this provider
+                        disposable.Dispose();
+                    }
+                }
+            }
+
+            lock (_contextLock)
+            {
+                if (contextInstances.Contains(Context))
+                    contextInstances.Remove(Context);
+            }
+        }
     }
 }

Core Modules/WalletConnectSharp.Events/EventHandlerMap.cs

@@ -7,7 +7,7 @@ namespace WalletConnectSharp.Events
     /// A mapping of eventIds to EventHandler objects. This using a Dictionary as the backing datastore
     /// </summary>
     /// <typeparam name="TEventArgs">The type of EventHandler's argument to store</typeparam>
-    public class EventHandlerMap<TEventArgs>
+    public class EventHandlerMap<TEventArgs> : IDisposable
     {
         private Dictionary<string, EventHandler<TEventArgs>> mapping =
             new Dictionary<string, EventHandler<TEventArgs>>();
@@ -94,5 +94,13 @@ public void Clear(string eventId)
                 }
             }
         }
+
+        public void Dispose()
+        {
+            lock (_mappingLock)
+            {
+                mapping.Clear();
+            }
+        }
     }
 }

Core Modules/WalletConnectSharp.Events/EventManager.cs

@@ -85,5 +85,15 @@ public void PropagateEvent(string eventId, T eventData)
                 }
             }
         }
+
+        public void Dispose()
+        {
+            EventTriggers.Dispose();
+            lock (_managerLock)
+            {
+                if (_instances.ContainsKey(Context))
+                    _instances.Remove(Context);
+            }
+        }
     }
 }

Core Modules/WalletConnectSharp.Events/Interfaces/IEventProvider.cs

@@ -5,7 +5,7 @@ namespace WalletConnectSharp.Events
     /// provider can trigger any event for a given event data type.
     /// </summary>
     /// <typeparam name="T">The event data type this class triggers events with</typeparam>
-    public interface IEventProvider<in T>
+    public interface IEventProvider<in T> : IDisposable
     {
         /// <summary>
         /// Trigger the given event (using the event id) with the given event data.
@@ -14,4 +14,4 @@ public interface IEventProvider<in T>
         /// <param name="eventData">The event data to trigger the event with</param>
         void PropagateEvent(string eventId, T eventData);
     }
-}
+}

Core Modules/WalletConnectSharp.Network/JsonRpcProvider.cs

@@ -304,5 +304,11 @@ private void OnPayload(object sender, GenericEvent<string> e)
                 }
             }
         }
+
+        public void Dispose()
+        {
+            _connection?.Dispose();
+            _delegator?.Dispose();
+        }
     }
 }

Core Modules/WalletConnectSharp.Storage/InMemoryStorage.cs

@@ -75,5 +75,10 @@ protected void IsInitialized()
                 throw WalletConnectException.FromType(ErrorType.NOT_INITIALIZED, "Storage");
             }
         }
+
+        public void Dispose()
+        {
+            Entries?.Clear();
+        }
     }
-}
+}

Core Modules/WalletConnectSharp.Storage/Interfaces/IKeyValueStorage.cs

@@ -5,7 +5,7 @@ namespace WalletConnectSharp.Storage.Interfaces
     /// <summary>
     /// The storage module handles the storing by key value pairing. All of the functions are asynchronous 
     /// </summary>
-    public interface IKeyValueStorage
+    public interface IKeyValueStorage : IDisposable
     {
         /// <summary>
         /// Initialize the storage. This should load any data or prepare any connection required by the
@@ -65,4 +65,4 @@ public interface IKeyValueStorage
         /// <returns></returns>
         Task Clear();
     }
-}
+}

Tests/WalletConnectSharp.Events.Tests/EventTests.cs

@@ -2,6 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
+using WalletConnectSharp.Common;
 using WalletConnectSharp.Common.Model;
 using WalletConnectSharp.Events.Model;
 using Xunit;
@@ -173,5 +174,89 @@ public void ListenAndDeserializeJson()
             Assert.Equal(result1.test1, testData1.test1);
             Assert.Equal(result1.test2, testData1.test2);
         }
+
+        public class TestModule : IModule
+        {
+            public void Dispose()
+            {
+                // TODO release managed resources here
+            }
+
+            public string Name
+            {
+                get
+                {
+                    return "test";
+                }
+            }
+
+            public string Context
+            {
+                get
+                {
+                    return $"{Name}-context";
+                }
+            }
+        }
+
+        [Fact, Trait("Category", "unit")]
+        public void TestContextSharingWithoutDisposingFails()
+        {
+            var module = new TestModule();
+            var events = new EventDelegator(module);
+
+            Assert.Equal(module.Context, events.Context);
+
+            Assert.Throws<ArgumentException>(() => new EventDelegator(module));
+
+            events.Dispose();
+
+            events = new EventDelegator(module);
+
+            Assert.Equal(module.Context, events.Context);
+
+            events.Dispose();
+        }
+
+        [Fact, Trait("Category", "unit")]
+        public void TestEventsDontLeakWhenDisposed()
+        {
+            var module = new TestModule();
+            var events = new EventDelegator(module);
+
+            Assert.Equal(module.Context, events.Context);
+
+            Assert.Throws<ArgumentException>(() => new EventDelegator(module));
+
+            TestEventData result1 = null;
+
+            events.ListenForAndDeserialize<TestEventData>("abc", delegate(object sender, GenericEvent<TestEventData> @event)
+            {
+                result1 = @event.EventData;
+            });
+
+            var testData1 = new TestEventData()
+            {
+                test1 = 11,
+                test2 = "abccc"
+            };
+
+            var json = JsonConvert.SerializeObject(testData1);
+
+            events.Trigger("abc", json);
+
+            Assert.Equal(result1.test1, testData1.test1);
+            Assert.Equal(result1.test2, testData1.test2);
+
+            events.Dispose();
+            result1 = null;
+
+            events = new EventDelegator(module);
+            events.Trigger("abc", json);
+
+            Assert.Null(result1);
+
+            events.Dispose();
+        }
     }
 }