Implemented WebRtcTransportAdapter.

Implemented FileSystem via WebRTC.
Improved FileSystemControl keyboard control.
Implemented FileSystemControl context menu.
Improved Transported custom request handler registration.
Implemented FS copy/move/delete.
Implemented InputBox.

1 files changed, 114 insertions, 3 deletions

diff --git a/Software/Visual_Studio/PPC/Tango.PPC.Common/FileSystem/DefaultFileSystemService.cs b/Software/Visual_Studio/PPC/Tango.PPC.Common/FileSystem/DefaultFileSystemService.cs
index cf7a21e13..512935b50 100644
--- a/Software/Visual_Studio/PPC/Tango.PPC.Common/FileSystem/DefaultFileSystemService.cs
+++ b/Software/Visual_Studio/PPC/Tango.PPC.Common/FileSystem/DefaultFileSystemService.cs
@@ -13,6 +13,8 @@ using Tango.FileSystem.Network;
 using Tango.Integration.ExternalBridge;
 using Tango.PPC.Common.ExternalBridge;
 using Tango.Transport;
+using Tango.Transport.Transporters;
+using Tango.WebRTC;
 
 namespace Tango.PPC.Common.FileSystem
 {
@@ -42,16 +44,61 @@ namespace Tango.PPC.Common.FileSystem
 
         private FileSystemManager _manager;
         private Dictionary<String, FileSystemOperation> _operations;
+        private Dictionary<ExternalBridgeReceiver, BasicTransporter> _webRtcClients;
 
         public bool Enabled { get; set; } = true;
+        public bool EnableWebRTC { get; set; } = true;
 
         public DefaultFileSystemService(IPPCExternalBridgeService externalBridge)
         {
+            _webRtcClients = new Dictionary<ExternalBridgeReceiver, BasicTransporter>();
             _manager = new FileSystemManager();
             _operations = new Dictionary<string, FileSystemOperation>();
             externalBridge.RegisterRequestHandler(this);
         }
 
+        [ExternalBridgeRequestHandlerMethod(typeof(InitWebRtcRequest))]
+        public async void OnInitWebRtcRequest(InitWebRtcRequest request, String token, ExternalBridgeReceiver receiver)
+        {
+            try
+            {
+                if (!EnableWebRTC)
+                {
+                    await receiver.SendErrorResponse(new InvalidOperationException("The file system service WebRTC channel is disabled on this machine."), token);
+                    return;
+                }
+
+                if (_webRtcClients.ContainsKey(receiver))
+                {
+                    _webRtcClients[receiver].Dispose();
+                }
+
+                var webRtcAdapter = new WebRtcTransportAdapter(receiver, WebRtcTransportAdapterMode.Passive, request.DataChannelName);
+                webRtcAdapter.Ready += (x, e) =>
+                {
+                    LogManager.Log("File System via WebRTC is ready.");
+                };
+
+                BasicTransporter webRtcTransporter = new BasicTransporter(webRtcAdapter);
+                webRtcTransporter = new BasicTransporter(webRtcAdapter);
+                webRtcTransporter.ComponentName = "File System Passive WebRTC Transporter";
+                webRtcTransporter.UseKeepAlive = false;
+                webRtcTransporter.RegisterRequestHandler<ChunkDownloadRequest>(WebRtcChunkDownloadRequestReceived);
+                await webRtcTransporter.Connect();
+                await receiver.SendGenericResponse(new InitWebRtcResponse(), token);
+                _webRtcClients[receiver] = webRtcTransporter;
+            }
+            catch (Exception ex)
+            {
+                await receiver.SendErrorResponse(ex, token);
+            }
+        }
+
+        private void WebRtcChunkDownloadRequestReceived(ITransporter transporter, ChunkDownloadRequest request, string token)
+        {
+            OnChunkDownloadRequest(request, token, transporter);
+        }
+
         [ExternalBridgeRequestHandlerMethod(typeof(GetFileSystemItemRequest))]
         public async void OnGetFileSystemItemRequest(GetFileSystemItemRequest request, String token, ExternalBridgeReceiver receiver)
         {
@@ -171,7 +218,7 @@ namespace Tango.PPC.Common.FileSystem
         }
 
         [ExternalBridgeRequestHandlerMethod(typeof(ChunkDownloadRequest))]
-        public async void OnChunkDownloadRequest(ChunkDownloadRequest request, String token, ExternalBridgeReceiver receiver)
+        public async void OnChunkDownloadRequest(ChunkDownloadRequest request, String token, ITransporter receiver)
         {
             FileSystemOperation operation;
             _operations.TryGetValue(request.OperationId, out operation);
@@ -182,16 +229,26 @@ namespace Tango.PPC.Common.FileSystem
                 return;
             }
 
-            using (FileStream stream = new FileStream(operation.Path, FileMode.Open))
+            FileStream stream = null;
+
+            try
             {
+                stream = new FileStream(operation.Path, FileMode.Open);
                 stream.Position = request.Position;
                 byte[] data = new byte[Math.Min(request.MaxChunkSize, stream.Length - stream.Position)];
                 await stream.ReadAsync(data, 0, data.Length);
+                stream.Dispose();
+                stream = null;
                 await receiver.SendGenericResponse(new ChunkDownloadResponse()
                 {
                     Data = data
                 }, token, new TransportResponseConfig() { Priority = QueuePriority.Low });
             }
+            catch (Exception ex)
+            {
+                stream?.Dispose();
+                await receiver.SendErrorResponse(ex, token);
+            }
         }
 
         [ExternalBridgeRequestHandlerMethod(typeof(AbortOperationRequest))]
@@ -235,9 +292,63 @@ namespace Tango.PPC.Common.FileSystem
             }
         }
 
-        public void OnReceiverDisconnected(ExternalBridgeReceiver receiver)
+        [ExternalBridgeRequestHandlerMethod(typeof(MoveRequest))]
+        public async void OnMoveRequest(MoveRequest request, String token, ExternalBridgeReceiver receiver)
         {
+            try
+            {
+                _manager.Move(request);
+                await receiver.SendGenericResponse(new MoveResponse(), token);
+            }
+            catch (Exception ex)
+            {
+                await receiver.SendErrorResponse(ex, token);
+            }
+        }
+
+        [ExternalBridgeRequestHandlerMethod(typeof(CopyRequest))]
+        public async void OnCopyRequest(CopyRequest request, String token, ExternalBridgeReceiver receiver)
+        {
+            try
+            {
+                _manager.Copy(request);
+                await receiver.SendGenericResponse(new CopyResponse(), token);
+            }
+            catch (Exception ex)
+            {
+                await receiver.SendErrorResponse(ex, token);
+            }
+        }
+
+        [ExternalBridgeRequestHandlerMethod(typeof(DeleteRequest))]
+        public async void OnDeleteRequest(DeleteRequest request, String token, ExternalBridgeReceiver receiver)
+        {
+            try
+            {
+                _manager.Delete(request.Path);
+                await receiver.SendGenericResponse(new DeleteResponse(), token);
+            }
+            catch (Exception ex)
+            {
+                await receiver.SendErrorResponse(ex, token);
+            }
+        }
 
+        public void OnReceiverDisconnected(ExternalBridgeReceiver receiver)
+        {
+            if (_webRtcClients.ContainsKey(receiver))
+            {
+                try
+                {
+                    var webRtcTransporter = _webRtcClients[receiver];
+                    _webRtcClients.Remove(receiver);
+                    webRtcTransporter.Dispose();
+                }
+                catch (Exception ex)
+                {
+                    LogManager.Log(ex, "Error disposing the WebRTC transporter.");
+                }
+            }
         }
     }
 }