Add Microcontrollers

Toolkit.Foundation/IHostBuilderExtension.cs

@@ -5,6 +5,7 @@ using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.FileProviders.Physical;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Options;
 using System.Text.Json;
 
 namespace Toolkit.Foundation;
@@ -196,6 +197,21 @@ public static class IHostBuilderExtension
         return builder;
     }
 
+    public static IHostBuilder ConfigureSerial<TConfiguration, TSerialReader, TContent>(this IHostBuilder hostBuilder,
+        Action<HostBuilderContext> configureDelegate) where TSerialReader : SerialReader<TContent>
+        where TConfiguration : ISerialConfiguration, new()
+    {
+        hostBuilder.ConfigureServices((hostBuilderContext, serviceCollection) =>
+        {
+            configureDelegate.Invoke(hostBuilderContext);
+
+            serviceCollection.TryAddSingleton<ISerialFactory, SerialFactory>();
+            serviceCollection.AddSingleton(provider => provider.GetService<ISerialFactory>()!.Create<TSerialReader, TContent>(provider.GetService<IOptionsMonitor<TConfiguration>>()!.CurrentValue));
+        });
+
+        return hostBuilder;
+    }
+
     public static IHostBuilder UseContentRoot(this IHostBuilder hostBuilder,
         string contentRoot,
         bool createDirectory)

Toolkit.Foundation/IMicrocontrollerBuilder.cs

@@ -0,0 +1,12 @@
+using Microsoft.Extensions.Configuration;
+
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerBuilder
+{
+    IReadOnlyCollection<IMicrocontrollerBuilderConfiguration> Configurations { get; }
+
+    IMicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer> Add<TConfiguration, TSerialReader, TRead, TReadDeserializer>(IConfiguration configuration)
+        where TConfiguration : IMicrocontrollerConfiguration, new()
+        where TSerialReader : SerialReader<TRead> where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new();
+}

Toolkit.Foundation/IMicrocontrollerBuilderConfiguration.cs

@@ -0,0 +1,17 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerBuilderConfiguration
+{
+    IReadOnlyCollection<IMicrocontrollerModuleDescriptor> Modules { get; }
+
+    Func<IServiceProvider, IMicrocontrollerContext> Factory { get; }
+}
+
+public interface IMicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer> :
+    IMicrocontrollerBuilderConfiguration where TConfiguration : IMicrocontrollerConfiguration, new()
+    where TSerialReader : SerialReader<TRead> where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new()
+{
+
+    IMicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer> AddModule<TModule>()
+        where TModule : IMicrocontrollerModule, new();
+}

Toolkit.Foundation/IMicrocontrollerConfiguration.cs

@@ -0,0 +1,4 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerConfiguration : 
+    ISerialConfiguration;

Toolkit.Foundation/IMicrocontrollerContext.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerContext<TRead, TModuleDeserializer> :
+    IMicrocontrollerContext where TModuleDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new();
+
+public interface IMicrocontrollerContext;

Toolkit.Foundation/IMicrocontrollerFactory.cs

@@ -0,0 +1,7 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerFactory
+{
+    IMicrocontrollerContext<TRead, TReadDeserializer> Create<TSerialReader, TRead, TReadDeserializer>(IMicrocontrollerConfiguration configuration, IReadOnlyCollection<IMicrocontrollerModuleDescriptor> modules)
+        where TSerialReader : SerialReader<TRead> where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new();
+}

Toolkit.Foundation/IMicrocontrollerModule.cs

@@ -0,0 +1,3 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerModule;

Toolkit.Foundation/IMicrocontrollerModuleDescriptor.cs

@@ -0,0 +1,12 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerModuleDescriptor<TModule> : 
+    IMicrocontrollerModuleDescriptor where TModule : IMicrocontrollerModule
+{
+    Func<TModule>? Factory { get; }
+}
+
+public interface IMicrocontrollerModuleDescriptor
+{
+    Type Type { get; }
+}

Toolkit.Foundation/IMicrocontrollerModuleDeserializer.cs

@@ -0,0 +1,6 @@
+namespace Toolkit.Foundation;
+
+public interface IMicrocontrollerModuleDeserializer<TRead>
+{
+    public TRead? Read { get; set; }
+}

Toolkit.Foundation/ISerialContext.cs

@@ -1,7 +1,9 @@
 namespace Toolkit.Foundation;
 
 public interface ISerialContext<TSerialReader, TContent> :
-    ISerialContext where TSerialReader : SerialReader<TContent>
+    ISerialContext where TSerialReader : SerialReader<TContent>;
-{
 
+public interface ISerialContext
+{
+    void Open();
 }

Toolkit.Foundation/ISerialContext1.cs

@@ -1,6 +0,0 @@
-namespace Toolkit.Foundation;
-
-public interface ISerialContext
-{
-    void Open();
-}

Toolkit.Foundation/MicrocontrollerBuilder.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Configuration;
+using System.Collections.ObjectModel;
+
+namespace Toolkit.Foundation;
+
+public class MicrocontrollerBuilder :
+    IMicrocontrollerBuilder
+{
+    private readonly List<IMicrocontrollerBuilderConfiguration> configurations = [];
+
+    public IReadOnlyCollection<IMicrocontrollerBuilderConfiguration> Configurations => 
+        new ReadOnlyCollection<IMicrocontrollerBuilderConfiguration>(configurations);
+
+    public IMicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer> Add<TConfiguration, TSerialReader, TRead, TReadDeserializer>(IConfiguration configuration)
+        where TConfiguration : IMicrocontrollerConfiguration, new()
+        where TSerialReader : SerialReader<TRead>
+        where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new()
+    {
+        MicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer>? builderConfiguration = new(configuration);
+        configurations.Add(builderConfiguration);
+
+        return builderConfiguration;
+    }
+}

Toolkit.Foundation/MicrocontrollerBuilderConfiguration.cs

@@ -0,0 +1,24 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.ObjectModel;
+
+namespace Toolkit.Foundation;
+
+public class MicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer>(IConfiguration configuration) : 
+    IMicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer>
+    where TConfiguration : IMicrocontrollerConfiguration, new()
+    where TSerialReader : SerialReader<TRead> where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new()
+{
+    private readonly List<IMicrocontrollerModuleDescriptor> modules = new();
+
+    public Func<IServiceProvider, IMicrocontrollerContext> Factory => (IServiceProvider provider) => provider.GetService<IMicrocontrollerFactory>()!.Create<TSerialReader, TRead, TReadDeserializer>(configuration.Get<TConfiguration>(), Modules);
+
+    public IReadOnlyCollection<IMicrocontrollerModuleDescriptor> Modules => new ReadOnlyCollection<IMicrocontrollerModuleDescriptor>(modules);
+
+    public IMicrocontrollerBuilderConfiguration<TConfiguration, TSerialReader, TRead, TReadDeserializer> AddModule<TModule>()
+        where TModule : IMicrocontrollerModule, new()
+    {
+        modules.Add(new MicrocontrollerModuleDescriptor<TModule>());
+        return this;
+    }
+}

Toolkit.Foundation/MicrocontrollerConfiguration.cs

@@ -0,0 +1,12 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Toolkit.Foundation;
+
+public class MicrocontrollerConfiguration : 
+    IMicrocontrollerConfiguration
+{
+    [NotNull]
+    public string? PortName { get; set; }
+
+    public int BaudRate { get; set; }
+}

Toolkit.Foundation/MicrocontrollerContext.cs

@@ -0,0 +1,23 @@
+using CommunityToolkit.Mvvm.Messaging;
+
+namespace Toolkit.Foundation;
+
+public class MicrocontrollerContext<TRead, TReadDeserializer>(IReadOnlyCollection<IMicrocontrollerModuleDescriptor> modules,
+    IMessenger messenger,
+    ISerialContext serialContext) : 
+    IMicrocontrollerContext<TRead, TReadDeserializer> where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new()
+{
+    public async Task InitializeAsync()
+    {
+        //eventAggregator.Subscribe<SerialResponse<TRead>>(OnEvent, null, args => args.Context.Equals(serialContext));
+        serialContext.Open();
+
+        await Task.CompletedTask;
+    }
+
+    private async void OnEvent(SerialResponse<TRead> args)
+    {
+        //IMicrocontrollerModule? module = await messenger.SendAsync<IMicrocontrollerModule>(new TReadDeserializer { Read = args.Content }, modules);
+        //messenger.Send((dynamic?)module);
+    }
+}

Toolkit.Foundation/MicrocontrollerFactory.cs

@@ -0,0 +1,23 @@
+namespace Toolkit.Foundation;
+
+public class MicrocontrollerFactory(IServiceFactory factory,
+    ISerialFactory serialFactory) : 
+    IMicrocontrollerFactory
+{
+    private readonly Dictionary<ISerialConfiguration, IMicrocontrollerContext> cache = new();
+
+    public IMicrocontrollerContext<TRead, TReadDeserializer> Create<TSerialReader, TRead, TReadDeserializer>(IMicrocontrollerConfiguration configuration, IReadOnlyCollection<IMicrocontrollerModuleDescriptor> modules) where TSerialReader : SerialReader<TRead> where TReadDeserializer : IMicrocontrollerModuleDeserializer<TRead>, new()
+    {
+        if (cache.TryGetValue(configuration, out IMicrocontrollerContext? context))
+        {
+            return (IMicrocontrollerContext<TRead, TReadDeserializer>)context;
+        }
+
+        ISerialContext<TSerialReader, TRead> serialContext = serialFactory.Create<TSerialReader, TRead>(configuration);
+
+        context = factory.Create<MicrocontrollerContext<TRead, TReadDeserializer>>(modules, serialContext);
+        cache.Add(configuration, context);
+
+        return (IMicrocontrollerContext<TRead, TReadDeserializer>)context;
+    }
+}

Toolkit.Foundation/MicrocontrollerModuleDescriptor.cs

@@ -0,0 +1,9 @@
+namespace Toolkit.Foundation;
+
+public record MicrocontrollerModuleDescriptor<TModule> : 
+    IMicrocontrollerModuleDescriptor<TModule> where TModule : IMicrocontrollerModule, new()
+{
+    public Type Type => typeof(TModule);
+
+    public Func<TModule>? Factory => new(() => new TModule());
+}

Toolkit.Foundation/SerialReaderHandler.cs

@@ -0,0 +1,9 @@
+using System.Buffers;
+
+namespace Toolkit.Foundation;
+
+public abstract class SerialReaderHandler<TRead> :
+    IAsyncHandler<TRead, ReadOnlySequence<byte>> where TRead : class
+{
+    public abstract Task<ReadOnlySequence<byte>> Handle(TRead args, CancellationToken cancellationToken = default);
+}