path: root/Software/Visual_Studio/FSE/Tango.FSE.UI/RemoteDesktop/DefaultRemoteDesktopProvider.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.DI;
using Tango.Core.ExtensionMethods;
using Tango.Core.Threading;
using Tango.FSE.Common.Authentication;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.Notifications;
using Tango.FSE.Common.RemoteDesktop;
using Tango.PMR;
using Tango.PMR.Integration;
using Tango.RemoteDesktop.Frames;
using Tango.RemoteDesktop.Network;
using Tango.Transport;
using Tango.WebRTC;

namespace Tango.FSE.UI.RemoteDesktop
{
    /// <summary>
    /// Represents the <see cref="IRemoteDesktopProvider"/> default implementation.
    /// </summary>
    /// <seealso cref="Tango.Core.ExtendedObject" />
    /// <seealso cref="Tango.FSE.Common.RemoteDesktop.IRemoteDesktopProvider" />
    public class DefaultRemoteDesktopProvider : ExtendedObject, IRemoteDesktopProvider
    {
        private class MouseMovement
        {
            public Point Location { get; set; }
            public Size ViewSize { get; set; }
        }

        private IMachineProvider _machineProvider;
        private RasterFrame _currentFrame;
        private MemoryStream _currentStream;
        private Size? _frameSize;
        private IntervalMessageDispatcher<StartRemoteDesktopSessionResponse> _frameDispatcher;
        private Thread _mouseMoveThread;
        private ProducerConsumerQueue<MouseMovement> _mouseMovements;
        private WebRtcClient _webRtcClient;
        private List<IceCandidate> _iceCandidates;
        private bool _answerReceived;
        private JsonSerializerSettings _jsonSettings;

        [TangoInject]
        private INotificationProvider NotificationProvider { get; set; }

        [TangoInject]
        private IAuthenticationProvider AuthenticationProvider { get; set; }

        #region Events

        /// <summary>
        /// Occurs when a new remote desktop screen frame is available.
        /// </summary>
        public event EventHandler<DesktopFrameReceivedEventArgs> FrameReceived;

        #endregion

        #region Properties

        private bool _inSession;
        /// <summary>
        /// Gets a value indicating whether a remote desktop session is active.
        /// </summary>
        public bool InSession
        {
            get { return _inSession; }
            set { _inSession = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(CanStartSession)); }
        }

        /// <summary>
        /// Gets or sets a value indicating whether enable the WebRTC channel.
        /// </summary>
        public bool EnableWebRtc { get; set; }

        private bool _isWebRtcActive;
        /// <summary>
        /// Gets a value indicating whether the WebRTC channel is available.
        /// </summary>
        public bool IsWebRtcActive
        {
            get { return _isWebRtcActive; }
            set
            {
                if (_isWebRtcActive != value)
                {
                    _isWebRtcActive = value;
                    RaisePropertyChangedAuto();

                    if (_isWebRtcActive)
                    {
                        LogManager.Log("WebRTC is now active.");
                    }
                }
            }
        }

        /// <summary>
        /// Gets or sets the mouse move send interval.
        /// </summary>
        public TimeSpan MouseMoveInterval { get; set; }

        /// <summary>
        /// Gets a value indicating whether a remote desktop session can be started.
        /// </summary>
        public bool CanStartSession
        {
            get { return _machineProvider.IsConnected && !InSession; }
        }

        #endregion

        #region Constructors

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultRemoteDesktopProvider"/> class.
        /// </summary>
        public DefaultRemoteDesktopProvider()
        {
            _jsonSettings = new JsonSerializerSettings()
            {
                TypeNameHandling = TypeNameHandling.All,
            };

            _iceCandidates = new List<IceCandidate>();
            MouseMoveInterval = TimeSpan.FromMilliseconds(100);
            EnableWebRtc = true;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultRemoteDesktopProvider"/> class.
        /// </summary>
        /// <param name="machineProvider">The machine provider.</param>
        public DefaultRemoteDesktopProvider(IMachineProvider machineProvider) : this()
        {
            _machineProvider = machineProvider;
            _machineProvider.MachineConnected += (_, __) =>
            {
                InSession = false;
            };
            _machineProvider.MachineDisconnected += (_, __) =>
            {
                InSession = false;
                OnFrameReceived(null);
            };

            _machineProvider.MachineOperator.RegisterRequestHandler<WebRtcIceCandidateRequest>(OnIceCandidateRequestReceived);
        }

        #endregion

        #region Request Handlers

        /// <summary>
        /// Called when a new ice candidate received from the remote peer.
        /// </summary>
        /// <param name="transporter">The transporter.</param>
        /// <param name="request">The request.</param>
        /// <param name="token">The token.</param>
        private async void OnIceCandidateRequestReceived(ITransporter transporter, WebRtcIceCandidateRequest request, string token)
        {
            try
            {
                LogManager.Log("Ice candidate request received from the remote peer. Adding ice candidate and sending confirmation response...");
                _webRtcClient.AddIceCandidate(request.IceCandidate);
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, $"Error adding ice candidate:\n{request.IceCandidate.ToJsonString()}");
            }

            try
            {
                await _machineProvider.MachineOperator.SendGenericResponse(new WebRtcIceCandidateResponse() { }, token);
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending Ice candidate confirmation response.");
            }
        }

        #endregion

        #region Start/Stop Session

        /// <summary>
        /// Starts a remote desktop session.
        /// </summary>
        /// <returns></returns>
        /// <exception cref="System.InvalidOperationException">Unable to start a remote desktop session at the moment.</exception>
        public async Task StartSession()
        {
            AuthenticationProvider.ThrowIfNoPermission(Permissions.FSE_RemoteDesktopView);

            TaskCompletionSource<bool> completionSource = new TaskCompletionSource<bool>();

            if (!CanStartSession)
            {
                throw new InvalidOperationException("Unable to start a remote desktop session at the moment.");
            }

            if (!InSession)
            {
                LogManager.Log("Starting remote desktop session...");

                _currentFrame = null;
                _currentStream = null;

                _iceCandidates.Clear();
                _answerReceived = false;

                InSession = true;

                var taskItem = NotificationProvider.PushTaskItem("Starting remote desktop session...");

                await Task.Delay(2000);

                if (_frameDispatcher != null)
                {
                    _frameDispatcher.Dispose();
                }

                _frameDispatcher = new IntervalMessageDispatcher<StartRemoteDesktopSessionResponse>(OnRemoteDesktopResponse);
                _frameDispatcher.DriftCompensationInterval = (int)TimeSpan.FromSeconds(10).TotalMilliseconds;
                _frameDispatcher.Start();

                bool taskCompleted = false;

                LogManager.Log("Sending continuous remote desktop session request...");

                _machineProvider.MachineOperator.SendGenericContinuousRequest<StartRemoteDesktopSessionRequest, StartRemoteDesktopSessionResponse>(new StartRemoteDesktopSessionRequest() { }, new TransportContinuousRequestConfig()
                {
                    Timeout = TimeSpan.FromSeconds(10)
                }).Subscribe((response) =>
                {
                    if (!taskCompleted)
                    {
                        LogManager.Log("Remote desktop session started.");
                        taskCompleted = true;
                        taskItem.Dispose();
                        completionSource.SetResult(true);

                        if (EnableWebRtc)
                        {
                            LogManager.Log("WebRTC for remote desktop is enabled. Starting WebRTC channel...");
                            StartWebRTC();
                        }
                    }

                    _frameDispatcher.Push(response);

                }, (ex) =>
                {
                    if (!taskCompleted)
                    {
                        taskCompleted = true;
                        taskItem.Dispose();
                        completionSource.SetException(ex);
                    }
                    else if (InSession)
                    {
                        OnFailed(ex);
                    }

                    InSession = false;
                }, () =>
                {
                    InSession = false;
                    OnFrameReceived(null);
                });

                await completionSource.Task;
            }
            else
            {
                await Task.FromResult(true);
            }
        }

        /// <summary>
        /// Ends the current remote desktop session.
        /// </summary>
        /// <returns></returns>
        public async Task EndSession()
        {
            if (InSession)
            {
                using (NotificationProvider.PushTaskItem("Stopping remote desktop session..."))
                {
                    LogManager.Log("Stopping remote desktop session...");
                    await Task.Delay(2000);

                    try
                    {
                        LogManager.Log("Sending stop remote desktop session request...");

                        await _machineProvider.MachineOperator.SendGenericRequest<StopRemoteDesktopSessionRequest, StopRemoteDesktopSessionResponse>(new StopRemoteDesktopSessionRequest(), new TransportRequestConfig()
                        {
                            ShouldLog = true
                        });

                        LogManager.Log("Remote desktop session stopped.");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error stopping the remote desktop session.");
                    }

                    DisposeWebRtc();

                    InSession = false;
                }
            }
        }

        #endregion

        #region Virtual Methods

        /// <summary>
        /// Raises the <see cref="FrameReceived"/> event.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="origin">The origin.</param>
        protected virtual void OnFrameReceived(BitmapSource source, DesktopFrameReceivedEventArgs.FrameOrigin origin = DesktopFrameReceivedEventArgs.FrameOrigin.WebSockets)
        {
            IsWebRtcActive = origin == DesktopFrameReceivedEventArgs.FrameOrigin.WebRTC;

            if (InSession)
            {
                FrameReceived?.Invoke(this, new DesktopFrameReceivedEventArgs()
                {
                    Source = source,
                    Origin = origin
                });
            }
        }

        #endregion

        #region SignalR Response Received

        /// <summary>
        /// Called when by the interval message dispatcher for processing a frame received by the standard SignalR channel.
        /// </summary>
        /// <param name="response">The response.</param>
        private void OnRemoteDesktopResponse(StartRemoteDesktopSessionResponse response)
        {
            if (!InSession) return; //To stop frame delivery immediately.

            if (response.Packet == null)
            {
                LogManager.Log($"Remote desktop session frame rate is now: {response.FrameRate} per second.");
                _frameDispatcher.Interval = 1000 / response.FrameRate;
                return; //This is the first message with empty bitmap and only the frame rate.
            }

            try
            {
                if (!response.Packet.IsPartial)
                {
                    _currentFrame?.Dispose();
                    _currentStream?.Dispose();

                    _currentStream = new MemoryStream(response.Packet.Bitmap);
                    _currentFrame = new RasterFrame(new System.Drawing.Bitmap(_currentStream));
                    _frameSize = new Size(_currentFrame.Width, _currentFrame.Height);
                }
                else
                {
                    using (MemoryStream ms = new MemoryStream(response.Packet.Bitmap))
                    {
                        var diffFrame = new RasterFrame(new System.Drawing.Bitmap(ms), response.Packet.PartialRegion.Left, response.Packet.PartialRegion.Top);
                        diffFrame.Apply(_currentFrame);
                        diffFrame.Dispose();
                    }
                }

                OnFrameReceived(_currentFrame.ToBitmapSource());
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error occurred while trying to process a remote desktop response.");
            }
        }

        #endregion

        #region Mouse/Keyboard

        /// <summary>
        /// Sends a mouse down command to the remote PPC.
        /// </summary>
        /// <param name="button">The button.</param>
        /// <param name="location">The location.</param>
        /// <param name="viewSize">Size of the view.</param>
        public async void MouseDown(MouseButton button, Point location, Size viewSize)
        {
            if (!InSession || _frameSize == null) return;
            if (!AuthenticationProvider.CurrentUser.HasPermission(Permissions.FSE_RemoteDesktopControl)) return;

            try
            {
                var request = new MouseStateRequest()
                {
                    Button = button,
                    EventType = MouseEventType.Down,
                    Location = TranslateLocation(location, viewSize)
                };

                if (IsWebRtcActive)
                {
                    SendWebRtcObject(request);
                }
                else
                {
                    await _machineProvider.MachineOperator.SendGenericRequest<MouseStateRequest, MouseStateResponse>(request);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending remote desktop mouse down command.");
            }
        }

        /// <summary>
        /// Sends a mouse up command to the remote PPC.
        /// </summary>
        /// <param name="button">The button.</param>
        /// <param name="location">The location.</param>
        /// <param name="viewSize">Size of the view.</param>
        public async void MouseUp(MouseButton button, Point location, Size viewSize)
        {
            if (!InSession || _frameSize == null) return;
            if (!AuthenticationProvider.CurrentUser.HasPermission(Permissions.FSE_RemoteDesktopControl)) return;

            try
            {
                var request = new MouseStateRequest()
                {
                    Button = button,
                    EventType = MouseEventType.Up,
                    Location = TranslateLocation(location, viewSize)
                };

                if (IsWebRtcActive)
                {
                    SendWebRtcObject(request);
                }
                else
                {
                    await _machineProvider.MachineOperator.SendGenericRequest<MouseStateRequest, MouseStateResponse>(request);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending remote desktop mouse up command.");
            }
        }

        /// <summary>
        /// Sends a mouse move command to the remote PPC.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="viewSize">Size of the view.</param>
        public void MouseMove(Point location, Size viewSize)
        {
            if (!InSession || _frameSize == null) return;
            if (!AuthenticationProvider.CurrentUser.HasPermission(Permissions.FSE_RemoteDesktopControl)) return;

            if (_mouseMoveThread == null)
            {
                _mouseMovements = new ProducerConsumerQueue<MouseMovement>();
                _mouseMoveThread = new Thread(async () =>
                {
                    while (InSession)
                    {
                        MouseMovement movement = _mouseMovements.BlockDequeue();

                        while (_mouseMovements.Count > 0)
                        {
                            movement = _mouseMovements.BlockDequeue();
                        }

                        try
                        {
                            var request = new MouseStateRequest()
                            {
                                Button = MouseButton.Left,
                                EventType = MouseEventType.Move,
                                Location = TranslateLocation(movement.Location, movement.ViewSize)
                            };

                            if (IsWebRtcActive)
                            {
                                SendWebRtcObject(request);
                            }
                            else
                            {
                                await _machineProvider.MachineOperator.SendGenericRequest<MouseStateRequest, MouseStateResponse>(request);
                            }
                        }
                        catch (Exception ex)
                        {
                            LogManager.Log(ex, "Error sending remote desktop mouse move command.");
                        }

                        Thread.Sleep(MouseMoveInterval);
                    }

                    _mouseMoveThread = null;
                });

                _mouseMoveThread.IsBackground = true;
                _mouseMoveThread.Start();
            }

            _mouseMovements.BlockEnqueue(new MouseMovement()
            {
                Location = location,
                ViewSize = viewSize,
            });
        }

        /// <summary>
        /// Sends a mouse double click command to the remote PPC.
        /// </summary>
        /// <param name="button">The button.</param>
        /// <param name="location">The location.</param>
        /// <param name="viewSize">Size of the view.</param>
        public async void MouseDoubleClick(MouseButton button, Point location, Size viewSize)
        {
            if (!InSession || _frameSize == null) return;
            if (!AuthenticationProvider.CurrentUser.HasPermission(Permissions.FSE_RemoteDesktopControl)) return;

            try
            {
                var request = new MouseStateRequest()
                {
                    Button = button,
                    EventType = MouseEventType.DoubleClick,
                    Location = TranslateLocation(location, viewSize)
                };

                if (IsWebRtcActive)
                {
                    SendWebRtcObject(request);
                }
                else
                {
                    await _machineProvider.MachineOperator.SendGenericRequest<MouseStateRequest, MouseStateResponse>(request);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending remote desktop mouse double click command.");
            }
        }

        /// <summary>
        /// Translates the location.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="viewSize">Size of the view.</param>
        /// <returns></returns>
        private Point TranslateLocation(Point location, Size viewSize)
        {
            return new Point(
                (location.X / viewSize.Width) * _frameSize.Value.Width,
                (location.Y / viewSize.Height) * _frameSize.Value.Height);
        }

        /// <summary>
        /// Sends a key down command to the remote PPC.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="ctrlDown">if set to <c>true</c> [control down].</param>
        /// <param name="shitDown">if set to <c>true</c> [shit down].</param>
        /// <param name="altDown">if set to <c>true</c> [alt down].</param>
        public async void KeyboardDown(Key key, bool ctrlDown, bool shitDown, bool altDown)
        {
            if (!InSession || _frameSize == null) return;
            if (!AuthenticationProvider.CurrentUser.HasPermission(Permissions.FSE_RemoteDesktopControl)) return;

            if (key == Key.LeftCtrl || key == Key.LeftShift || key == Key.LeftAlt) return;

            try
            {
                var request = new KeyboardStateRequest()
                {
                    EventType = KeyboardEventType.Down,
                    Key = key,
                    IsCtrlDown = ctrlDown,
                    IsShiftDown = shitDown,
                    IsAltDown = altDown,
                };

                if (IsWebRtcActive)
                {
                    SendWebRtcObject(request);
                }
                else
                {
                    await _machineProvider.MachineOperator.SendGenericRequest<KeyboardStateRequest, KeyboardStateResponse>(request);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending remote desktop key down command.");
            }
        }

        /// <summary>
        /// Sends a key up command to the remote PPC.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="ctrlDown">if set to <c>true</c> [control down].</param>
        /// <param name="shitDown">if set to <c>true</c> [shit down].</param>
        /// <param name="altDown">if set to <c>true</c> [alt down].</param>
        public async void KeyboardUp(Key key, bool ctrlDown, bool shitDown, bool altDown)
        {
            if (!InSession || _frameSize == null) return;
            if (!AuthenticationProvider.CurrentUser.HasPermission(Permissions.FSE_RemoteDesktopControl)) return;

            if (key == Key.LeftCtrl || key == Key.LeftShift || key == Key.LeftAlt) return;

            try
            {
                var request = new KeyboardStateRequest()
                {
                    EventType = KeyboardEventType.Up,
                    Key = key,
                    IsCtrlDown = ctrlDown,
                    IsShiftDown = shitDown,
                    IsAltDown = altDown,
                };

                if (IsWebRtcActive)
                {
                    SendWebRtcObject(request);
                }
                else
                {
                    await _machineProvider.MachineOperator.SendGenericRequest<KeyboardStateRequest, KeyboardStateResponse>(request);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending remote desktop key up command.");
            }
        }

        #endregion

        #region Commands

        /// <summary>
        /// Sends the specified predefined remote desktop command.
        /// </summary>
        /// <param name="command">The command.</param>
        public async void SendCommand(RemoteDesktopCommand command)
        {
            AuthenticationProvider.ThrowIfNoPermission(Permissions.FSE_RemoteDesktopControl);

            try
            {
                await _machineProvider.MachineOperator.SendGenericRequest<RemoteDesktopCommandRequest, RemoteDesktopCommandResponse>(new RemoteDesktopCommandRequest());
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, $"Error sending remote desktop command '{command}'.");
            }
        }

        #endregion

        #region WebRTC

        /// <summary>
        /// Starts the WebRTC channel.
        /// </summary>
        private async void StartWebRTC()
        {
            try
            {
                LogManager.Log("Starting Remote desktop WebRTC channel...");
                _webRtcClient = new WebRtcClient();

                _webRtcClient.NewIceCandidate += _webRtcClient_NewIceCandidate;
                _webRtcClient.FrameReceived += _webRtcClient_FrameReceived;
                _webRtcClient.Disconnected += _webRtcClient_Disconnected;

                LogManager.Log("Initializing WebRTC client...");
                await _webRtcClient.Init();

                LogManager.Log("Creating WebRTC offer...");
                var offer = await _webRtcClient.CreateOffer();

                LogManager.Log("Sending WebRTC offer...");
                var response = await _machineProvider.MachineOperator.SendGenericRequest<WebRtcOfferRequest, WebRtcOfferResponse>(new WebRtcOfferRequest() { Offer = offer }, new TransportRequestConfig()
                {
                    Timeout = TimeSpan.FromSeconds(30)
                });

                LogManager.Log("Remote desktop WebRTC offer sent and responded with an answer. Setting WebRTC answer...");
                _webRtcClient.SetAnswer(response.Answer);
                _answerReceived = true;

                foreach (var ice in _iceCandidates.ToList())
                {
                    LogManager.Log("Sending any existing ice candidate...");

                    try
                    {
                        await _machineProvider.MachineOperator.SendGenericRequest<WebRtcIceCandidateRequest, WebRtcIceCandidateResponse>(new WebRtcIceCandidateRequest() { IceCandidate = ice }, new TransportRequestConfig()
                        {
                            Timeout = TimeSpan.FromSeconds(30),
                        });
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error sending existing ice candidate. Ignoring...");
                    }
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error starting WebRTC.");
            }
        }

        /// <summary>
        /// Disposes the WebRTC channel.
        /// </summary>
        private void DisposeWebRtc()
        {
            if (_webRtcClient != null)
            {
                LogManager.Log("Disposing remote desktop WebRTC channel...");

                _webRtcClient.NewIceCandidate -= _webRtcClient_NewIceCandidate;
                _webRtcClient.FrameReceived -= _webRtcClient_FrameReceived;
                _webRtcClient.Disconnected -= _webRtcClient_Disconnected;

                if (_webRtcClient != null)
                {
                    try
                    {
                        _webRtcClient.Dispose();
                        _webRtcClient = null;
                        LogManager.Log("Remote desktop WebRTC channel disposed properly.");
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error occurred while disposing remote desktop WebRTC channel.");
                    }
                }
            }
        }

        /// <summary>
        /// Handles the <see cref="WebRtcClient.Disconnected"/> event.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void _webRtcClient_Disconnected(object sender, EventArgs e)
        {
            LogManager.Log("The remote desktop WebRTC channel has disconnected.");
            IsWebRtcActive = false;
        }

        /// <summary>
        /// Handles the <see cref="WebRtcClient.NewIceCandidate"/> event.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="NewIceCandidateEventArgs"/> instance containing the event data.</param>
        private async void _webRtcClient_NewIceCandidate(object sender, NewIceCandidateEventArgs e)
        {
            try
            {
                if (_answerReceived)
                {
                    LogManager.Log("New remote desktop WebRTC candidate available. Sending ice to remote peer...");

                    await _machineProvider.MachineOperator.SendGenericRequest<WebRtcIceCandidateRequest, WebRtcIceCandidateResponse>(new WebRtcIceCandidateRequest() { IceCandidate = e.IceCandidate }, new TransportRequestConfig()
                    {
                        Timeout = TimeSpan.FromSeconds(30),
                        ShouldLog = true
                    });
                }
                else
                {
                    LogManager.Log("New remote desktop WebRTC candidate available. Will be sent after an answer is received...");
                    _iceCandidates.Add(e.IceCandidate);
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error sending remote desktop ice candidate to remote peer.");
            }
        }

        /// <summary>
        /// Handles the <see cref="WebRTC.VideoFrameReceivedEventArgs"/> event.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="VideoFrameReceivedEventArgs"/> instance containing the event data.</param>
        private void _webRtcClient_FrameReceived(object sender, VideoFrameReceivedEventArgs e)
        {
            try
            {
                RasterFrame frame = new RasterFrame(e.Bitmap);
                OnFrameReceived(frame.ToBitmapSource(), DesktopFrameReceivedEventArgs.FrameOrigin.WebRTC);
                frame.Dispose();
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error while processing a remote desktop frame received by WebRTC channel.");
            }
        }

        /// <summary>
        /// Sends a serialized JSON object via the WebRTC data channel.
        /// </summary>
        /// <param name="obj">The object.</param>
        private void SendWebRtcObject(object obj)
        {
            _webRtcClient.SendText(JsonConvert.SerializeObject(obj, _jsonSettings));
        }

        #endregion

        #region OnFailed

        /// <summary>
        /// Called when the current remote desktop channel has completely failed.
        /// </summary>
        /// <param name="exception">The exception.</param>
        private void OnFailed(Exception exception)
        {
            LogManager.Log(exception, "The current remote desktop session has failed.");

            InSession = false;
            OnFrameReceived(null);
            DisposeWebRtc();

            if (!(exception is TransporterDisconnectedException))
            {
                NotificationProvider.PushSnackbarItem(MessageType.Error, "Remote desktop session terminated unexpectedly.", true, null, TimeSpan.FromSeconds(5));
            }
        }

        #endregion
    }
}