refactoring: channel creation (#254)

Author: ShortDevelopment

lib/ShortDev.Microsoft.ConnectedDevices.NearShare/NearShareSender.cs

@@ -21,15 +21,13 @@ async Task<SenderStateMachine> PrepareTransferInternalAsync(EndpointInfo endpoin
 
         Guid operationId = Guid.NewGuid();
 
-        using var handShakeChannel = await session.StartClientChannelAsync<HandshakeHandler>(cancellationToken).ConfigureAwait(false);
-        HandshakeHandler handshake = new(handShakeChannel);
+        var handshake = await session.StartClientChannelAsync<HandshakeHandler>(cancellationToken).ConfigureAwait(false);
         await handshake.Execute(operationId).ConfigureAwait(false);
 
         // ToDo: CorrelationVector
         // var cv = handshakeResultMsg.Header.TryGetCorrelationVector() ?? throw new InvalidDataException("No Correlation Vector");
 
-        var channel = await session.StartClientChannelAsync(operationId.ToString("D").ToUpper(), NearShareApp.Name, cancellationToken).ConfigureAwait(false);
-        SenderStateMachine senderStateMachine = new(channel);
+        var senderStateMachine = await session.StartClientChannelAsync<SenderStateMachine>(operationId.ToString("D").ToUpper(), NearShareApp.Name, cancellationToken).ConfigureAwait(false);
         return senderStateMachine;
     }
 
@@ -48,7 +46,7 @@ public async Task SendFilesAsync(CdpDevice device, IReadOnlyList<CdpFileProvider
         await senderStateMachine.SendFilesAsync(files, progress, cancellationToken).ConfigureAwait(false);
     }
 
-    sealed class HandshakeHandler(CdpChannel channel) : CdpBondApp(channel), ICdpAppId
+    sealed class HandshakeHandler(CdpChannel channel) : CdpBondApp(channel), ICdpAppFactory<HandshakeHandler>, ICdpAppId
     {
         public static string Id { get; } = NearShareHandshakeApp.Id;
         public static string Name { get; } = NearShareHandshakeApp.Name;
@@ -76,9 +74,11 @@ protected override void HandleMessage(in BinaryMsgHeader header, ValueSet payloa
 
             _promise.SetResult();
         }
+
+        static HandshakeHandler ICdpAppFactory<HandshakeHandler>.Create(CdpChannel channel) => new(channel);
     }
 
-    sealed class SenderStateMachine(CdpChannel channel) : CdpBondApp(channel)
+    sealed class SenderStateMachine(CdpChannel channel) : CdpBondApp(channel), ICdpAppFactory<SenderStateMachine>
     {
         readonly TaskCompletionSource _promise = new();
         public async Task SendUriAsync(Uri uri)
@@ -199,6 +199,8 @@ void HandleDataRequest(BinaryMsgHeader header, ValueSet payload)
             });
         }
 
+        static SenderStateMachine ICdpAppFactory<SenderStateMachine>.Create(CdpChannel channel) => new(channel);
+
         private readonly struct DataResponseMessage : IBinaryWritable<DataResponseMessage>
         {
             public required CdpFileProvider FileProvider { get; init; }

lib/ShortDev.Microsoft.ConnectedDevices/CdpAppRegistration.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
 
 namespace ShortDev.Microsoft.ConnectedDevices;
 
@@ -17,6 +18,9 @@ public static class CdpAppRegistration
 
     private static readonly ConcurrentDictionary<string, AppId> _registration = new(StringComparer.OrdinalIgnoreCase);
 
+    public static void RegisterApp<TApp>() where TApp : CdpAppBase, ICdpAppFactory<TApp>, ICdpAppId
+        => RegisterApp(TApp.Id, TApp.Name, TApp.Create);
+
     public static void RegisterApp<TApp>(CdpAppFactory<TApp> factory) where TApp : CdpAppBase, ICdpAppId
         => RegisterApp(TApp.Id, TApp.Name, factory);
 
@@ -39,4 +43,25 @@ internal static CdpAppBase InstantiateApp(string id, string name, CdpChannel cha
 
         return _registration[id].Factory(channel);
     }
+
+    internal static bool TryGetAppFactory(string id, string name, [MaybeNullWhen(false)] out CdpAppFactory<CdpAppBase> factory)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(id);
+        ArgumentException.ThrowIfNullOrEmpty(name);
+
+        if (!_registration.TryGetValue(id, out var appId))
+        {
+            factory = null;
+            return false;
+        }
+
+        factory = appId.Factory;
+        return true;
+    }
+}
+
+public interface ICdpAppFactory<out TApp>
+    where TApp : CdpAppBase
+{
+    static abstract TApp Create(CdpChannel channel);
 }

lib/ShortDev.Microsoft.ConnectedDevices/CdpChannel.cs

@@ -74,19 +74,17 @@ void IDisposable.Dispose()
 
     public void Dispose(bool closeSession = false, bool closeSocket = false)
     {
+        MessageReceived = null;
+
         _handler.UnregisterChannel(this);
         if (closeSocket)
             Socket.Dispose(); // ToDo: Heartbeat!
         if (closeSession)
             Session.Dispose(); // ToDo: Heartbeat!
     }
 
-    internal static CdpChannel CreateServerChannel(ChannelHandler handler, CdpSocket socket, StartChannelRequest request, ulong channelId, out CdpAppBase app)
-    {
-        CdpChannel channel = new(handler, channelId, socket);
-        app = CdpAppRegistration.InstantiateApp(request.Id, request.Name, channel);
-        return channel;
-    }
+    internal static CdpChannel CreateServerChannel(ChannelHandler handler, CdpSocket socket, ulong channelId)
+        => new(handler, channelId, socket);
 
     internal static CdpChannel CreateClientChannel(ChannelHandler handler, CdpSocket socket, StartChannelResponse response)
         => new(handler, response.ChannelId, socket);

lib/ShortDev.Microsoft.ConnectedDevices/CdpSession.cs

@@ -207,8 +207,19 @@ void HandleSession(CommonHeader header, ref HeapEndianReader reader)
     }
     #endregion
 
-    public Task<CdpChannel> StartClientChannelAsync<TApp>(CancellationToken cancellationToken = default) where TApp : ICdpAppId
-        => StartClientChannelAsync(TApp.Id, TApp.Name, cancellationToken);
+    public async Task<TApp> StartClientChannelAsync<TApp>(CancellationToken cancellationToken = default)
+        where TApp : CdpAppBase, ICdpAppFactory<TApp>, ICdpAppId
+    {
+        var channel = await StartClientChannelAsync(TApp.Id, TApp.Name, cancellationToken).ConfigureAwait(false);
+        return TApp.Create(channel);
+    }
+
+    public async Task<TApp> StartClientChannelAsync<TApp>(string appId, string appName, CancellationToken cancellationToken = default)
+        where TApp : CdpAppBase, ICdpAppFactory<TApp>
+    {
+        var channel = await StartClientChannelAsync(appId, appName, cancellationToken).ConfigureAwait(false);
+        return TApp.Create(channel);
+    }
 
     public async Task<CdpChannel> StartClientChannelAsync(string appId, string appName, CancellationToken cancellationToken = default)
     {

lib/ShortDev.Microsoft.ConnectedDevices/Session/Channels/HostChannelHandler.cs

@@ -20,10 +20,20 @@ protected override void HandleMessageInternal(CdpSocket socket, CommonHeader hea
             new byte[] { 0x30, 0x0, 0x0, 0x1 }
         ));
         header.RequestID = 0;
+        header.Flags = 0;
 
-        _channelRegistry.Create(channelId => CdpChannel.CreateServerChannel(this, socket, request, channelId, out _), out var channelId);
+        (ChannelResult result, ulong channelId) result;
+        if (!CdpAppRegistration.TryGetAppFactory(request.Id, request.Name, out var appFactory))
+        {
+            result = (ChannelResult.Failure_NotFound, 0);
+        }
+        else
+        {
+            var channel = _channelRegistry.Create(channelId => CdpChannel.CreateServerChannel(this, socket, channelId), out var channelId);
+            appFactory(channel);
+            result = (ChannelResult.Success, channelId);
+        }
 
-        header.Flags = 0;
         Session.SendMessage(
             socket,
             ref header,
@@ -33,8 +43,8 @@ protected override void HandleMessageInternal(CdpSocket socket, CommonHeader hea
             },
             new StartChannelResponse()
             {
-                Result = ChannelResult.Success,
-                ChannelId = channelId
+                Result = result.result,
+                ChannelId = result.channelId
             }
         );
     }