added asynchelper to run task/async method synchronously

Added TransponderUtility Factories and providers to irdaemon.

RaceLapTimer/Interfaces/ITransponderUtilities.cs

@@ -1,7 +0,0 @@
-namespace Interfaces
-{
-    public interface ITransponderUtilities
-    {
-        int GetLastScannedIdAsync();
-    }
-}

RaceLapTimer/Interfaces/ITransponderUtilityManager.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Interfaces
+{
+    public interface ITransponderUtilityManager
+    {
+        List<ITransponderUtilityProvider> GetProviders();
+
+        int GetLastScannedId();
+    }
+}

RaceLapTimer/Interfaces/ITransponderUtilityProvider.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Interfaces
+{
+    public interface ITransponderUtilityProvider
+    {
+        Task<int> GetLastScannedIdAsync();
+    }
+}

RaceLapTimer/Interfaces/ITransponderUtilityProviderFactory.cs

@@ -2,6 +2,6 @@
 {
     public interface ITransponderUtilityProviderFactory
     {
-        ITransponderUtilities GetProvider();
+        ITransponderUtilityProvider GetProvider();
     }
 }

RaceLapTimer/Interfaces/Interfaces.csproj

@@ -53,7 +53,8 @@
     <Compile Include="ISystemControl.cs" />
     <Compile Include="ISystemControlManager.cs" />
     <Compile Include="ISystemControlProviderFactory.cs" />
-    <Compile Include="ITransponderUtilities.cs" />
+    <Compile Include="ITransponderUtilityProvider.cs" />
+    <Compile Include="ITransponderUtilityManager.cs" />
     <Compile Include="ITransponderUtilityProviderFactory.cs" />
     <Compile Include="NotificationEventArgs.cs" />
     <Compile Include="Pilot.cs" />

RaceLapTimer/IrDaemonNotifier/IdDaemonTransponderUtilityFactory.cs

@@ -0,0 +1,12 @@
+using Interfaces;
+
+namespace IrDaemonNotifier
+{
+    public class IdDaemonTransponderUtilityFactory : ITransponderUtilityProviderFactory
+    {
+        public ITransponderUtilityProvider GetProvider()
+        {
+            return new IrDaemonTransponderUtilities();
+        }
+    }
+}

RaceLapTimer/IrDaemonNotifier/IrDaemonController.cs

@@ -10,12 +10,4 @@ namespace IrDaemonNotifier
             Debug.WriteLine("test");
         }
     }
-
-    public class IrDaemonControllerProviderFactory : ISystemControlProviderFactory
-    {
-        public ISystemControl GetProvider()
-        {
-            return new IrDaemonController();
-        }
-    }
 }

RaceLapTimer/IrDaemonNotifier/IrDaemonNotifier.csproj

@@ -40,9 +40,12 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="IdDaemonTransponderUtilityFactory.cs" />
     <Compile Include="IrDaemonController.cs" />
+    <Compile Include="IrDaemonControllerProviderFactory.cs" />
     <Compile Include="IrDaemonNotifier.cs" />
     <Compile Include="IrDaemonNotifierProviderFactory.cs" />
+    <Compile Include="IrDaemonTransponderUtilities.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

RaceLapTimer/IrDaemonNotifier/IrDaemonTransponderUtilities.cs

@@ -0,0 +1,13 @@
+using System.Threading.Tasks;
+using Interfaces;
+
+namespace IrDaemonNotifier
+{
+    public class IrDaemonTransponderUtilities : ITransponderUtilityProvider
+    {
+        public Task<int> GetLastScannedIdAsync()
+        {
+            return Task.FromResult(-1);
+        }
+    }
+}

RaceLapTimer/RaceLapTimer/AuthenticationBootstrapper.cs

@@ -10,6 +10,7 @@ using Ninject;
 using RaceLapTimer.Extensions;
 using RaceLapTimer.Extensions.Notifications;
 using RaceLapTimer.Extensions.SystemControl;
+using RaceLapTimer.Extensions.TransponderUtilities;
 
 namespace RaceLapTimer
 {
@@ -38,9 +39,10 @@ namespace RaceLapTimer
 
             container.Bind<INotifierManager>().To<NotificationManager>().InSingletonScope();
             container.Bind<ISystemControlManager>().To<SystemControlManager>().InSingletonScope();
+            container.Bind<ITransponderUtilityManager>().To<TransponderUtilityManager>().InSingletonScope();
 
-            var sM = container.Get<ISystemControlManager>();
-            sM.Shutdown();
+            var tM = container.Get<ITransponderUtilityManager>();
+            tM.GetLastScannedId();
         }
 
         protected override void ConfigureRequestContainer(IKernel container, NancyContext context)

RaceLapTimer/RaceLapTimer/Extensions/TransponderUtilities/TransponderUtilityManager.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Interfaces;
+using RaceLapTimer.Helpers;
+
+namespace RaceLapTimer.Extensions.TransponderUtilities
+{
+    class TransponderUtilityManager:ITransponderUtilityManager
+    {
+        private List<ITransponderUtilityProvider> _providers;
+        private readonly ILoggerService _logger;
+
+        public TransponderUtilityManager(ILoggerService logger, IPluginLocator locator)
+        {
+            _logger = logger;
+            RegisterProviders(locator);
+        }
+
+        private void RegisterProviders(IPluginLocator locator)
+        {
+            try
+            {
+                var providerFactories = locator.Locate<ITransponderUtilityProviderFactory>();
+                _providers = new List<ITransponderUtilityProvider>();
+                foreach (var factory in providerFactories)
+                {
+                    _providers.Add(factory.GetProvider());
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex);
+            }
+        }
+
+        public List<ITransponderUtilityProvider> GetProviders()
+        {
+            return _providers;
+        }
+
+        public int GetLastScannedId()
+        {
+            //TODO: Implement a utlity provider selector, this can only work with one transponder utility provider.
+            if (_providers.Any())
+            {
+                var provider = _providers.First();
+                var lastId = AsyncHelpers.RunSync(_providers.First().GetLastScannedIdAsync);
+                _logger.Trace("Got Id {0} from provider {1}", lastId, provider.GetType().Name);
+                return lastId;
+            }
+            return -1;
+        }
+    }
+}

RaceLapTimer/RaceLapTimer/Helpers/AsyncHelpers.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace RaceLapTimer.Helpers
+{
+    public static class AsyncHelpers
+    {
+        /// <summary>
+        /// Execute's an async Task<T> method which has a void return value synchronously
+        /// </summary>
+        /// <param name="task">Task<T> method to execute</param>
+        public static void RunSync(Func<Task> task)
+        {
+            var oldContext = SynchronizationContext.Current;
+            var synch = new ExclusiveSynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(synch);
+            synch.Post(async _ =>
+            {
+                try
+                {
+                    await task();
+                }
+                catch (Exception e)
+                {
+                    synch.InnerException = e;
+                    throw;
+                }
+                finally
+                {
+                    synch.EndMessageLoop();
+                }
+            }, null);
+            synch.BeginMessageLoop();
+
+            SynchronizationContext.SetSynchronizationContext(oldContext);
+        }
+
+        /// <summary>
+        /// Execute's an async Task<T> method which has a T return type synchronously
+        /// </summary>
+        /// <typeparam name="T">Return Type</typeparam>
+        /// <param name="task">Task<T> method to execute</param>
+        /// <returns></returns>
+        public static T RunSync<T>(Func<Task<T>> task)
+        {
+            var oldContext = SynchronizationContext.Current;
+            var synch = new ExclusiveSynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(synch);
+            T ret = default(T);
+            synch.Post(async _ =>
+            {
+                try
+                {
+                    ret = await task();
+                }
+                catch (Exception e)
+                {
+                    synch.InnerException = e;
+                    throw;
+                }
+                finally
+                {
+                    synch.EndMessageLoop();
+                }
+            }, null);
+            synch.BeginMessageLoop();
+            SynchronizationContext.SetSynchronizationContext(oldContext);
+            return ret;
+        }
+
+        private class ExclusiveSynchronizationContext : SynchronizationContext
+        {
+            private bool done;
+            public Exception InnerException { get; set; }
+            readonly AutoResetEvent workItemsWaiting = new AutoResetEvent(false);
+            readonly Queue<Tuple<SendOrPostCallback, object>> items =
+                new Queue<Tuple<SendOrPostCallback, object>>();
+
+            public override void Send(SendOrPostCallback d, object state)
+            {
+                throw new NotSupportedException("We cannot send to our same thread");
+            }
+
+            public override void Post(SendOrPostCallback d, object state)
+            {
+                lock (items)
+                {
+                    items.Enqueue(Tuple.Create(d, state));
+                }
+                workItemsWaiting.Set();
+            }
+
+            public void EndMessageLoop()
+            {
+                Post(_ => done = true, null);
+            }
+
+            public void BeginMessageLoop()
+            {
+                while (!done)
+                {
+                    Tuple<SendOrPostCallback, object> task = null;
+                    lock (items)
+                    {
+                        if (items.Count > 0)
+                        {
+                            task = items.Dequeue();
+                        }
+                    }
+                    if (task != null)
+                    {
+                        task.Item1(task.Item2);
+                        if (InnerException != null) // the method threw an exeption
+                        {
+                            throw new AggregateException("AsyncHelpers.Run method threw an exception.", InnerException);
+                        }
+                    }
+                    else
+                    {
+                        workItemsWaiting.WaitOne();
+                    }
+                }
+            }
+
+            public override SynchronizationContext CreateCopy()
+            {
+                return this;
+            }
+        }
+    }
+}

RaceLapTimer/RaceLapTimer/RaceLapTimer.csproj

@@ -116,6 +116,7 @@
   <ItemGroup>
     <Compile Include="Extensions\PluginLocator.cs" />
     <Compile Include="Extensions\SystemControl\SystemControlManager.cs" />
+    <Compile Include="Extensions\TransponderUtilities\TransponderUtilityManager.cs" />
     <Compile Include="IDbProvider.cs" />
     <Compile Include="ApiControllers\LapTrackApiModule.cs" />
     <Compile Include="ApiControllers\MonitorApiModule.cs" />