path: root/Software/Visual_Studio/PPC/Tango.PPC.Common/RemoteDesktop/DefaultRemoteDesktopService.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Authentication;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using Tango.Core;
using Tango.Core.DI;
using Tango.Integration.ExternalBridge;
using Tango.PPC.Common.Application;
using Tango.PPC.Common.ExternalBridge;
using Tango.RemoteDesktop;
using Tango.RemoteDesktop.CaptureMethods;
using Tango.RemoteDesktop.Encoders;
using Tango.RemoteDesktop.Engines;
using Tango.RemoteDesktop.Frames;
using Tango.RemoteDesktop.Input;
using Tango.RemoteDesktop.Network;
using Tango.Settings;
using Tango.Transport;
using Tango.WebRTC;
using static Tango.RemoteDesktop.Input.MouseController;

namespace Tango.PPC.Common.RemoteDesktop
{
    [TangoCreateWhenRegistered]
    public class DefaultRemoteDesktopService : ExtendedObject, IRemoteDesktopService, IExternalBridgeRequestHandler
    {
        private class RemoteDesktopClient
        {
            public String Token { get; set; }
            public ExternalBridgeReceiver Receiver { get; set; }
            public bool InitialPacketSent { get; set; }
            public WebRtcClient WebRtcClient { get; set; }
            public bool IsWebRtcReady { get; set; }
        }

        private RemoteDesktopPacket _initialPacket;
        private RasterScreenCaptureEngine _engine;
        private PPCSettings _settings;
        private List<RemoteDesktopClient> _clients;


        private bool _isStarted;
        public bool IsStarted
        {
            get { return _isStarted; }
            private set { _isStarted = value; RaisePropertyChangedAuto(); }
        }

        public bool InSession
        {
            get
            {
                return _clients.Count > 0;
            }
        }

        public DefaultRemoteDesktopService(IPPCApplicationManager applicationManager, IPPCExternalBridgeService externalBridge)
        {
            _settings = SettingsManager.Default.GetOrCreate<PPCSettings>();
            applicationManager.ApplicationReady += ApplicationManager_ApplicationReady;

            externalBridge.RegisterRequestHandler(this);

            _clients = new List<RemoteDesktopClient>();
            _engine = new RasterScreenCaptureEngine();

            _engine.CaptureCursor = false;

            _engine.FrameRate = Math.Min(Math.Max(_settings.RemoteDesktopFrameRate, 1), 20);
            _engine.FrameReceived += _engine_FrameReceived;
        }

        private void ApplicationManager_ApplicationReady(object sender, EventArgs e)
        {

#if DEBUG
            _engine.CaptureMethod.Dispose();

            var mainWindow = System.Windows.Application.Current.MainWindow;
            mainWindow.LocationChanged += (_, __) =>
            {
                _engine.CaptureRegion = new CaptureRegion()
                {
                    Left = (int)mainWindow.Left + 10,
                    Top = (int)mainWindow.Top + 5,
                    Width = (int)mainWindow.Width - 20,
                    Height = (int)mainWindow.Height - 15
                };
            };

            _engine.CaptureRegion = new CaptureRegion()
            {
                Left = (int)mainWindow.Left + 10,
                Top = (int)mainWindow.Top + 5,
                Width = (int)mainWindow.Width - 20,
                Height = (int)mainWindow.Height - 15
            };
            _engine.CaptureMethod = new GdiScreenCapture();
#endif

            _engine.Comparer.MaxDifferencesThrow = _engine.CaptureRegion.Width * _engine.CaptureRegion.Height / 2;
        }

        [ExternalBridgeRequestHandlerMethod(typeof(StartRemoteDesktopSessionRequest))]
        public async void OnStartRemoteDesktopSessionRequestReceived(StartRemoteDesktopSessionRequest request, String token, ExternalBridgeReceiver receiver)
        {
            if (!_settings.EnableRemoteDesktop)
            {
                await receiver.SendErrorResponse(new AuthenticationException("Remote desktop is disabled on this machine."), token);
                return;
            }

            var client = _clients.SingleOrDefault(x => x.Receiver == receiver);

            if (client != null)
            {
                _clients.Remove(client);
            }

            RemoteDesktopClient newClient = new RemoteDesktopClient();
            newClient.Receiver = receiver;
            newClient.Token = token;
            newClient.WebRtcClient = new WebRtcClient();
            _clients.Add(newClient);

            await receiver.SendGenericResponse(new StartRemoteDesktopSessionResponse()
            {
                FrameRate = _engine.FrameRate
            }, token);

            if (_settings.EnableRemoteDesktop)
            {
                if (!_engine.IsStarted)
                {
                    _engine.Start();
                }
            }

            RaisePropertyChanged(nameof(InSession));
        }

        [ExternalBridgeRequestHandlerMethod(typeof(WebRtcIceCandidateRequest))]
        public async void OnWebRtcIceCandidateRequestReceived(WebRtcIceCandidateRequest request, String token, ExternalBridgeReceiver receiver)
        {
            var client = _clients.SingleOrDefault(x => x.Receiver == receiver);

            if (client != null)
            {
                try
                {
                    await receiver.SendGenericResponse(new WebRtcIceCandidateResponse() { }, token);
                    client.WebRtcClient.AddIceCandidate(request.IceCandidate);
                }
                catch (Exception ex)
                {
                    LogManager.Log($"Error adding WebRTC ice candidate received from the remote connection.\n{ex.FlattenMessage()}");
                }
            }
        }

        [ExternalBridgeRequestHandlerMethod(typeof(WebRtcOfferRequest))]
        public async void OnWebRtcOfferRequestReceived(WebRtcOfferRequest request, String token, ExternalBridgeReceiver receiver)
        {
            var client = _clients.SingleOrDefault(x => x.Receiver == receiver);

            if (client != null)
            {
                try
                {

                    try
                    {
                        client.WebRtcClient.NewIceCandidate += async (x, e) =>
                        {
                            try
                            {
                                await receiver.SendGenericRequest<WebRtcIceCandidateRequest, WebRtcIceCandidateResponse>(new WebRtcIceCandidateRequest() { IceCandidate = e.IceCandidate });
                            }
                            catch (Exception ex)
                            {
                                LogManager.Log(ex, $"Error sending ice candidate to remote peer.\n{ex.FlattenMessage()}");
                            }
                        };
                        client.WebRtcClient.Ready += (x, e) =>
                        {
                            client.IsWebRtcReady = true;
                        };
                        client.WebRtcClient.Disconnected += (x, e) =>
                        {
                            client.IsWebRtcReady = false;
                        };

                        client.WebRtcClient.FrameWidth = 800;
                        client.WebRtcClient.FrameHeight = 1280;
                        client.WebRtcClient.FrameRate = _engine.FrameRate;

                        await client.WebRtcClient.Init();

                        var answer = await client.WebRtcClient.CreateAnswer(request.Offer);
                        await receiver.SendGenericResponse(new WebRtcOfferResponse() { Answer = answer }, token);
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log($"Error initializing the web RTC client.\n{ex.FlattenMessage()}");
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Log($"Error responding to WebRTC offer request.\n{ex.FlattenMessage()}");
                }
            }
        }

        [ExternalBridgeRequestHandlerMethod(typeof(StopRemoteDesktopSessionRequest))]
        public async void OnStopRemoteDesktopSessionRequestReceived(StopRemoteDesktopSessionRequest request, String token, ExternalBridgeReceiver receiver)
        {
            var client = _clients.SingleOrDefault(x => x.Receiver == receiver);

            if (client != null)
            {
                _clients.Remove(client);

                if (client.WebRtcClient != null)
                {
                    client.WebRtcClient.Dispose();
                }
            }

            if (_clients.Count == 0)
            {
                _engine.Stop();
            }

            await receiver.SendGenericResponse(new StopRemoteDesktopSessionResponse(), token);

            if (client != null)
            {
                await receiver.SendGenericResponse(new StartRemoteDesktopSessionResponse(), client.Token, new TransportResponseConfig() { Completed = true });
            }

            RaisePropertyChanged(nameof(InSession));
        }

        [ExternalBridgeRequestHandlerMethod(typeof(MouseStateRequest))]
        public async void OnMouseStateRequestReceived(MouseStateRequest request, String token, ExternalBridgeReceiver receiver)
        {
            MouseController.SetCursorPosition((int)request.Location.X, (int)request.Location.Y);

            if (request.EventType == MouseEventType.Up || request.EventType == MouseEventType.Down)
            {
                MouseEventFlags flag = MouseEventFlags.LeftUp;

                switch (request.EventType)
                {
                    case MouseEventType.Down:
                        flag = request.Button == MouseButton.Right ? MouseEventFlags.RightDown : MouseEventFlags.LeftDown;
                        break;
                    case MouseEventType.Up:
                        flag = request.Button == MouseButton.Right ? MouseEventFlags.RightUp : MouseEventFlags.LeftUp;
                        break;
                }

                MouseController.MouseEvent(flag);
            }
            else if (request.EventType == MouseEventType.DoubleClick)
            {
                MouseController.MouseEvent(MouseEventFlags.LeftDown);
                MouseController.MouseEvent(MouseEventFlags.LeftUp);
                MouseController.MouseEvent(MouseEventFlags.LeftDown);
                MouseController.MouseEvent(MouseEventFlags.LeftUp);
            }

            await receiver.SendGenericResponse(new MouseStateResponse(), token);
        }

        [ExternalBridgeRequestHandlerMethod(typeof(KeyboardStateRequest))]
        public async void OnKeyboardStateRequestReceived(KeyboardStateRequest request, String token, ExternalBridgeReceiver receiver)
        {
            if (request.EventType == KeyboardEventType.Down)
            {
                KeyboardController.KeyDown(request.Key, request.IsCtrlDown, request.IsShiftDown, request.IsAltDown);
            }
            else
            {
                KeyboardController.KeyUp(request.Key, request.IsCtrlDown, request.IsShiftDown, request.IsAltDown);
            }

            await receiver.SendGenericResponse(new KeyboardStateResponse(), token);
        }

        private async void _engine_FrameReceived(object sender, ScreenCaptureFrameReceivedEventArgs<RasterFrame> e)
        {
            _initialPacket = new RemoteDesktopPacket()
            {
                Bitmap = e.Frame.ToEncoder<PngEncoder>().ToArray(),
            };

            if (_clients.Count > 0)
            {
                bool useWebRTC = _clients.ToList().All(x => x.IsWebRtcReady);

                if (useWebRTC)
                {
                    _engine.EnableComparer = false;

                    foreach (var client in _clients.ToList())
                    {
                        try
                        {
                            client.WebRtcClient.PushFrame(e.Frame.ToBitmap());
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine(ex);
                        }
                    }

                    e.Frame.Dispose();
                }
                else
                {
                    _engine.EnableComparer = true;

                    foreach (var client in _clients.ToList().Where(x => !x.InitialPacketSent))
                    {
                        try
                        {
                            await client.Receiver.SendGenericResponse(new StartRemoteDesktopSessionResponse()
                            {
                                Packet = _initialPacket,
                            }, client.Token, new TransportResponseConfig()
                            {
                                Immediate = false,
                            });

                            client.InitialPacketSent = true;
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine(ex);
                        }
                    }

                    if (e.Frame.DifferenceCount > 0)
                    {
                        RemoteDesktopPacket packet = null;

                        if (!e.Frame.DifferenceAvailable)
                        {
                            Debug.WriteLine("Using Jpeg...");
                            packet = new RemoteDesktopPacket()
                            {
                                Bitmap = e.Frame.ToEncoder<TurboJpegEncoder>().ToArray(30)
                            };
                        }
                        else
                        {
                            var diffFrame = e.Frame.ToDifference();
                            diffFrame = diffFrame.OptimizeBounds();

                            packet = new RemoteDesktopPacket()
                            {
                                Bitmap = diffFrame.ToEncoder<PngEncoder>().ToArray(),
                                IsPartial = true,
                                PartialRegion = new CaptureRegion(diffFrame.Left, diffFrame.Top, diffFrame.Width, diffFrame.Height),
                            };

                            diffFrame.Dispose();
                        }

                        Debug.WriteLine($"Bitmap Size: {packet.Bitmap.Length / 1000} kb");

                        foreach (var client in _clients.ToList().Where(x => x.InitialPacketSent))
                        {
                            try
                            {
                                await client.Receiver.SendGenericResponse(new StartRemoteDesktopSessionResponse()
                                {
                                    Packet = packet
                                }, client.Token, new TransportResponseConfig()
                                {
                                    Immediate = false,
                                });
                            }
                            catch (Exception ex)
                            {
                                Debug.WriteLine(ex);
                            }
                        }
                    }
                }
            }

            e.Frame.Dispose();
        }

        public void OnReceiverDisconnected(ExternalBridgeReceiver receiver)
        {
            var client = _clients.SingleOrDefault(x => x.Receiver == receiver);

            if (client != null)
            {
                _clients.Remove(client);

                try
                {
                    if (client.WebRtcClient != null)
                    {
                        client.WebRtcClient.Dispose();
                    }
                }
                catch (Exception ex)
                {
                    LogManager.Log($"Error disposing the WebRTC client.\n{ex.FlattenMessage()}");
                }
            }

            if (_clients.Count == 0)
            {
                _engine.Stop();
            }

            RaisePropertyChanged(nameof(InSession));
        }
    }
}