/// Version 1.0.0
/// Last modified 24.5.2014
///
/// Copyright (C) 2014 Veli-Mikko Puupponen, Ilkka Rautiainen, Atte Söderlund and Niko Mononen.
///
/// Halyri-system is a prototype emergency call system. Its purpose is to
/// demonstrate the use of the advanced capabilities available in the current
/// generation smartphones in facilitating the emergency service dispatcher's
/// capability to determine the nature of the emergency and to dispatch help.
///
/// For more information, see the README file of this package.
///
/// The MIT License (MIT)
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to
/// deal in the Software without restriction, including without limitation the
/// rights to use, copy, modify, merge, publish, distribute, sublicense,
/// and/or sell copies of the Software, and to permit persons to whom the
/// Software is furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
/// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
/// IN THE SOFTWARE.
///

using Hake_WPF.CallCenterReference;
using Hake_WPF.Conversion;
using System;
using System.Diagnostics;
using System.Linq;
using System.ServiceModel;
using System.Threading.Tasks;
using System.Collections.ObjectModel;
using Microsoft.Maps.MapControl.WPF;
using System.Threading;
using SimpleUdpMediaClient;
using SimpleUdpMediaClient.Packets;
using System.Windows.Media;

namespace Hake_WPF
{
    /// <summary>
    /// The class delegate is invoked when the connection receives an update.
    /// </summary>
    /// <param name="newConnections">List of the connections received from the server.</param>
    public delegate void ConnectionsUpdated(ConnectionDto[] newConnections);
    /// <summary>
    /// The class delegate is invoked when TcpMedia is received.
    /// </summary>
    /// <param name="sender">Source object that invokes this delegate.</param>
    /// <param name="info">Information about recived data.</param>
    /// <param name="data">Recived data packet.</param>
    public delegate void TcpMediaDataReceived(object sender, MediaInformationDto info, byte[] data);
    /// <summary>
    /// The class delegate is invoked when udp media is received.
    /// </summary>
    /// <param name="sender">Source object that invokes this delegate.</param>
    /// <param name="media">Recived media packet.</param>
    public delegate void UdpMediaDataReceived(object sender, MediaPacket media);

    /// <summary>
    /// The class delegate is invoked when measurement data media is received.
    /// </summary>
    /// <param name="sender">Source object that invokes this delegate.</param>
    /// <param name="e">Delegate event arguments.</param>
    /// <param name="instrument">Sending instrument.</param>
    /// <param name="measurementData">Recived measurement data.</param>
    /// <param name="dataSamplesPerSecond">Samples per second for recived measurement data.</param>
    public delegate void MeasurementDataReceivedDelegate(object sender, EventArgs e, MeasurementInstrumentDto instrument, byte[] measurementData, int dataSamplesPerSecond);

    /// <summary>
    /// The class receives data from the server which invokes an event.
    /// </summary>
    class AsyncReceiver : IWcfCallCenterServiceCallback
    {
        /// <summary>
        /// It is a delegate that is triggered when new media is received.
        /// </summary>
        public TcpMediaDataReceived TcpMediaDataReceivedEvent;
        /// <summary>
        /// It is a delegate that is triggered when meausrement data is received.
        /// </summary>
        public MeasurementDataReceivedDelegate MeasurementDataReceivedEvent;
        /// <summary>
        /// It is a event that is triggered when the server tells the client that the connections have changed.
        /// </summary>
        public event ConnectionsUpdated ConnectionsUpdatedEvent;

        /// <author>Veli-Mikko Puupponen</author>
        /// <summary>
        /// The class delegate is invoked everytime the client receives an update for assignment from the server.
        /// This method only invokes ConnectionsUpdatedEvent so Connection class can handle it.
        /// </summary>
        /// <param name="updatedConnections">List of changed connections.</param>
        public void ActiveConnectionsUpdated(ConnectionDto[] updatedConnections)
        {
            if (ConnectionsUpdatedEvent != null)
                ConnectionsUpdatedEvent(updatedConnections);
            foreach (ConnectionDto connection in updatedConnections)
            {
                Debug.WriteLine("Connection updated:" + connection.ArrivalTime.ToShortTimeString() + " " + connection.ConnectionGuid + " " + connection.ConnectionState.ToString());
            }
        }

        /// <summary>
        /// The function invokes tcpMediaDataReceivedEvent.
        /// </summary>
        public void AudioVideoReceived(string sourceGuid, MediaInformationDto mediaInfo, byte[] mediaData)
        {
            if (TcpMediaDataReceivedEvent != null)
                TcpMediaDataReceivedEvent(this, mediaInfo, mediaData);
        }

        /// <summary>
        /// The function invokes MeasurementDateReceivedEvent.
        /// </summary>
        public void MeasurementDataReceived(string sourceGuid, MeasurementInstrumentDto instrument, byte[] measurementData)
        {
            if(MeasurementDataReceivedEvent != null)
                MeasurementDataReceivedEvent(this, EventArgs.Empty, instrument, measurementData, instrument.DataSamplesPerSecond);
            Debug.WriteLine("MeasurementData received: " + instrument.DeviceType.ToString() + " " + measurementData);
        }
    }

    /// <author>Atte Söderlund</author>
    /// <summary>
    /// The class handles the communication between the server and this client. A user must use connect method to connect the server.
    /// After that the user can use rest of the methods to manage connection. Also the client should handle most of the events, but at least
    /// connectionupdatedevent.
    /// </summary>
    class Connection
    {
        private const int udpServerPort = 15103;
        private const string udpServerIp = "130.234.9.165";
        private WcfCallCenterServiceClient client;
        private string guid;
        private InstanceContext context;
        private CallCenterConnectionDto userConnection;
        private ObservableCollection<ConnectionDto> connectionDtos = new ObservableCollection<ConnectionDto>();
        private ConnectionDto currentConnection;
        private UserCredentialsDto userCredentialsDto;
        private UdpMediaClientSocket udpSocket;
        private bool isConnected = false;

        /// <summary>
        /// The function gets and sets AsyncReceiver. It handles the connection between the server and the client.
        /// </summary>
        public AsyncReceiver receiver { get; set; }

        /// <summary>
        /// The class delegate is invoked when the connection is updated.
        /// </summary>
        /// <param name="newConnections">The connections as Assignments.</param>
        public delegate void AssigmentUpdated(ObservableCollection<Assignment> newConnections);
        /// <summary>
        /// The event is triggered when the assinment is updated.
        /// </summary>
        public event AssigmentUpdated AssigmentUpdatedEvent;

        /// <summary>
        /// The class delegate is invoked when the current connection is setted.
        /// </summary>
        public delegate void AssignmentTakenForHandling();
        /// <summary>
        ///  The event is triggered when the assinment is taken to handlin.
        /// </summary>
        public event AssignmentTakenForHandling AssignmentTakenForHandlingEvent;
        /// <summary>
        /// The class delegate is invoked when udp media is received.
        /// </summary>
        public UdpMediaDataReceived UdpMediaDataReceivedEvent;

        /// <summary>
        /// The function creates a connection with the credentials provided.
        /// </summary>
        /// <param name="username">The username that connection uses.</param>
        /// <param name="password">The password that connection uses.</param>
        public Connection(String username, String password)
        {
            userCredentialsDto = new UserCredentialsDto() {UserName=username, Password=password };
            receiver = new AsyncReceiver();
            InitializeUdpClient();
        }

        /// <summary>
        /// The function initializes a new UdpMediaClientSocket instance for media transfer from
        /// and to the server.
        /// </summary>
        private void InitializeUdpClient()
        {
            udpSocket = new UdpMediaClientSocket(udpServerIp, udpServerPort, guid = Guid.NewGuid().ToString());
            udpSocket.MediaPacketReceivedEvent += UdpMediaPacketReceivedHandler;
            udpSocket.ConnectionFailedEvent += UdpSocketFailedEventHandler;
        }

        /// <summary>
        /// Handles incoming media packet events from the active 
        /// UdpMediaClientSocket instance. Republishes them as 
        /// UdpMediaDataReceivedEvent.
        /// </summary>
        /// <param name="sender">UdpMediaDataReceivedEvent event punlishing this event.</param>
        /// <param name="mediaPacket">The received MediaPacket instance.</param>
        private void UdpMediaPacketReceivedHandler(object sender, MediaPacket mediaPacket) 
        {
            if (UdpMediaDataReceivedEvent != null)
                UdpMediaDataReceivedEvent(sender, mediaPacket);
        }

        /// <summary>
        /// The function creates a receiver and connects to the server with wcf and udp.
        /// </summary>
        /// <returns>ObservableCollection of connections as assignments.</returns>
        public ObservableCollection<Assignment> Connect(String endpointAddress)
        {
            receiver.ConnectionsUpdatedEvent += receiver_ConnectionsUpdatedEvent;
            context = new InstanceContext(receiver);
            client = new WcfCallCenterServiceClient(new InstanceContext(receiver), new NetTcpBinding() { Security = new NetTcpSecurity() {Mode=SecurityMode.None } },
                new EndpointAddress(new Uri(endpointAddress)));
            try
            {
                userConnection = client.Connect(userCredentialsDto);
            }
            catch (EndpointNotFoundException endpointExeption)
            {
                Debug.WriteLine("Not connected: " + endpointExeption.Message);
                return new ObservableCollection<Assignment> { };
            }
            catch(Exception ex)
            {
                Debug.WriteLine("Error in connecting: " + ex.Message);
                return new ObservableCollection<Assignment> { };
            }
            Debug.WriteLine("Connected, using guid " + userConnection.ConnectionGuid);
            udpSocket.Connect();
            isConnected = true;
            return GetAllConnections();         
        }

        /// <summary>
        /// The function sends media to the server using the active UdpMediaClientSocket instance.
        /// It returns true, if the data is successfully queued for sending. Otherwise returns false.
        /// </summary>
        /// <param name="mediaInfo">The description of the media.</param>
        /// <param name="data">The bytes constituting the media data.</param>
        /// <param name="originalLength">The length of the media prior to the encoding for such encodings 
        /// that require the length for decompression.</param>
        /// <returns>True, if the data is queued for sending, otherwise false.</returns>
        public bool UdpSendMedia(MediaInformation mediaInfo, byte[] data, int originalLength) 
        {
            if (udpSocket != null)
                return udpSocket.SendMedia(mediaInfo, data, originalLength);
            return false;
        }

        /// <summary>
        /// Handles failure events of the active UdpMediaClientSocket.
        /// Currently only writes this information to the debug.
        /// </summary>
        /// <param name="sender">UdpMediaClientSocket instance sending the event.</param>
        private void UdpSocketFailedEventHandler(object sender) 
        {
            Debug.WriteLine("Udp socket has failed");
        }

        /// <summary>
        /// The function chances the priority to current connection and then updates that to the connections list and finaly to the server.
        /// It makes the connection in a new thread so it won't block the ui thread.
        /// </summary>
        /// <param name="assignment">The assignment that needs updating.</param>
        /// <param name="priority">The priority for the assignment  to be changed.</param>
        public void ChangePriority(Assignment assignment,Assignment.priorities priority)
        {
            Thread thread = new Thread(ChangePriorityThread);
            thread.Start(priority);
        }

        /// <summary>
        /// If there is no current connection this will not do anything. If there is it changes
        /// current connections priorit and send it to server.
        /// </summary>
        /// <param name="priority">New priority.</param>
        private void ChangePriorityThread(object priority)
        {
            if (currentConnection == null)
                return;
            currentConnection.ConnectionPriority = (ConnectionPriorityDto)(int)priority;
            UpdateConnectionsList(new ConnectionDto[] { currentConnection });
            client.SetConnectionPriority(userConnection, currentConnection);
        }

        /// <summary>
        /// Handles when connectionupdates are received. Updates connectionslist and invokes event for update with
        /// connectiondto's converted to assignments.
        /// </summary>
        /// <param name="newConnections">New connections.</param>
        private void receiver_ConnectionsUpdatedEvent(ConnectionDto[] newConnections)
        {
            UpdateConnectionsList(newConnections);
            Debug.WriteLine("ReceivedUpdate");
            if (AssigmentUpdatedEvent != null)
                AssigmentUpdatedEvent(ConvertConnectionsToAssigments(newConnections));      
        }

        /// <summary>
        /// Replaces connections with new connections by comparing their guid. If there is no
        /// connection with that guid, adds new connection.
        /// </summary>
        /// <param name="newConnections">New connetions.</param>
        private void UpdateConnectionsList(ConnectionDto[] newConnections)
        {
            for (int i = 0; i < newConnections.Length;i++ )
            {
                ConnectionDto connection = connectionDtos.FirstOrDefault((connect => connect.ConnectionGuid.Contains(newConnections[i].ConnectionGuid)));
                if (connection != null)
                {
                    int index = connectionDtos.IndexOf(connection);
                    connectionDtos.Insert(index, connection);
                    connectionDtos.RemoveAt(index + 1);
                }
                else
                    connectionDtos.Add(newConnections[i]);
            }
        }

        /// <summary>
        /// The function converts ConnectionDto to Assignment. If the location is not set, it uses null and do not
        /// assign the accuracymeters or the time from the location.
        /// If device info is empty, uses empty DeviceInfoDto.
        /// </summary>
        /// <param name="Connection">ConnectionDto that needs converting to Assigment.</param>
        /// <returns>Converted Assigment.</returns>
        public ObservableCollection<Assignment> ConvertConnectionsToAssigments(ConnectionDto[] Connections)
        {
            ObservableCollection<Assignment> assignments = new ObservableCollection<Assignment>();
            foreach (ConnectionDto connection in Connections)
            {           
                MobileDeviceInformationDto deviceInfo;
                LocationInformationDto latestNotUserSpecificLocation = null;
                LocationInformationDto latestUserSpecificLocation = null;
                try
                {
                    latestNotUserSpecificLocation = connection.LocationInformation.OrderByDescending(x => x.AcquisitionTime).
                        First((x =>x.LocationType != LocationTypeDto.UserSpecified));
                }
                catch(InvalidOperationException e)
                {
                    Debug.WriteLine("There was no location on connectiondto: " + e.Message);
                }
                catch(Exception e)
                {
                    Debug.WriteLine("Error: " + e.Message);
                }
                try
                {
                    latestUserSpecificLocation = connection.LocationInformation.OrderByDescending(x => x.AcquisitionTime)
                        .First((x => x.LocationType == LocationTypeDto.UserSpecified));
                }
                catch (Exception) { }
                try
                {
                    deviceInfo = connection.MobileDeviceInformation[0];
                }
                catch (IndexOutOfRangeException)
                {
                    deviceInfo = new MobileDeviceInformationDto();
                }
                assignments.Add(new Assignment(connection.ConnectionGuid, connection.ArrivalTime,
                    (Assignment.priorities)(int)connection.ConnectionPriority, (Assignment.States)(int)connection.ConnectionState,
                     (latestNotUserSpecificLocation == null)?latestUserSpecificLocation : latestNotUserSpecificLocation)
                    {
                        DeviceInfo = deviceInfo,
                        NoSound = connection.RequestedNoSound,
                        TextMessages = new ObservableCollection<TextMessageDto>(connection.TextMessages.OrderBy(con => con.TimeStamp)),
                        PersonalInfo = connection.PersonalInformation,
                        LocationAccuracyMeters = (latestNotUserSpecificLocation != null) ? latestNotUserSpecificLocation.AccuracyMeters : 0,
                        LocationAcquisitionTime = (latestNotUserSpecificLocation != null) ? latestNotUserSpecificLocation.AcquisitionTime :
                            DateTimeOffset.MinValue,
                        ClientConnected = !connection.clientDisconnected,
                        Pushpins = new ObservableCollection<Pushpin>()
                        {
                            (latestNotUserSpecificLocation != null)?new Pushpin()
                            {
                                Location = new Location(latestNotUserSpecificLocation.Latitude,latestNotUserSpecificLocation.Longitude),
                                ToolTip = latestNotUserSpecificLocation.AcquisitionTime + "\nTarkkuus: " + latestNotUserSpecificLocation.AccuracyMeters + " m"
                            } : null,
                            (latestUserSpecificLocation != null)?new Pushpin()
                            {
                                Location = new Location(latestUserSpecificLocation.Latitude,latestUserSpecificLocation.Longitude),
                                Background = Brushes.LightGreen,
                                ToolTip = latestUserSpecificLocation.AcquisitionTime + "\nTarkkuus: " + latestUserSpecificLocation.AccuracyMeters + " m"
                            } : null
                        },
                        EmergencyType = (connection.EmergencyType != null) ? connection.EmergencyType.TypeName : ""
                    });   
            }
            return assignments;
        }
      
        /// <summary>
        /// The function requests an action for the current user connection from caller with the given action. CurrentConnection must be specified 
        /// or this function does nothing.
        /// </summary>
        /// <param name="action">What action should be carried out.</param>
        public void RequestAction(RemoteActionDto action)
        {
            if (currentConnection == null)
                return;
            try
            {
                client.RequestRemoteAction(userConnection, currentConnection, action);
            }
            catch(Exception e)
            {
                Debug.WriteLine("Error in requesting action: " + e.Message);
            }
        }

        /// <author>Niko Mononen</author>
        /// <summary>
        /// If there is current connection specified, this function requests the measurements data to start from the server with the given instrument.
        /// </summary>
        /// <param name="instrument">The instrument that provides data.</param>
        public void RequestMeasurementData(MeasurementInstrumentDto instrument)
        {
            if (currentConnection == null)
                return;
            try
            {
                client.RequestStartMeasurementAsync(userConnection, currentConnection, instrument);
            }
            catch (Exception e)
            {
                Debug.WriteLine("Error in requesting measurement start: " + e.Message);
            }
        }

        /// <author>Niko Mononen</author>
        /// <summary>
        /// The function cancels the request to the server to stop measurement data sending. The Current connection is needed for this.
        /// </summary>
        /// <param name="instrument">The instrument that is sending the data.</param>
        public void CancelMeasurementData(MeasurementInstrumentDto instrument)
        {
            if (currentConnection == null)
                return;
            try
            {
                client.RequestStopMeasurementAsync(userConnection, currentConnection, instrument);
            }
            catch (Exception e)
            {
                Debug.WriteLine("Error in requesting action: " + e.Message);
            }
        }

        /// <summary>
        /// The function returns boolean whether the user is connected to server or not.
        /// </summary>
        /// <returns>Boolean whether connection established or not.</returns>
        public bool IsConnected()
        {
            return isConnected;
        }

        /// <summary>
        /// The function requests all connections from the server  and converts the server response to the assignment list.
        /// This function should be used only one time to save localy and then use ActiveConnectionsUpdated to update those.
        /// </summary>
        /// <returns>ObservableCollection of all connections as Assignment.</returns>
        public ObservableCollection<Assignment> GetAllConnections()
        {
            try
            {
                ConnectionDto[] connections = client.GetActiveConnections(userConnection);
                connectionDtos = new ObservableCollection<ConnectionDto>(connections);
                return ConvertConnectionsToAssigments(connections);
            }
            catch(Exception e)
            {
                Debug.WriteLine("Error in geting alla connections: " + e.Message);
            }
            return new ObservableCollection<Assignment>();
        }

        /// <summary>
        /// The function reconnects to the server.
        /// </summary>
        /// <returns>True when reconnection  goes without an error and false if there is any error.</returns>
        public bool Reconnect()
        {
            try
            {
                client.Reconnect(userConnection);
                isConnected = true;
            }
            catch(Exception e)
            {
                Debug.WriteLine("Error in reconnect: " + e.Message);
                return false;
            }
            return true;
        }

        /// <summary>
        /// The function disconnects from the server.
        /// </summary>
        /// <returns>True when disconnection is carried out without an error and false if there is any error.</returns>
        public bool Disconnect()
        {
            try
            {
                client.Disconnect(userConnection);
                udpSocket.Disconnect();
                isConnected = false;
            }
            catch(Exception e)
            {
                Debug.WriteLine("Error in disconnect: " + e.Message);
                isConnected = false;
                return false;
            }
            return true;
        }

        /// <summary>
        /// The function changes the assignments state to in progress to the server. First it search the right connection using guid and then makes
        /// the connection as current connection.
        /// </summary>
        /// <param name="assignment">The assignment that is to be set as in progress.</param>
        public void ProcessAssignment(object assignment)
        {
            ConnectionDto connection = connectionDtos.First((connect => connect.ConnectionGuid.Contains((assignment as Assignment).Guid)));
            if (connection == null)
                return;
            try
            {
                client.OpenConnectionForProcessing(userConnection, connection);
                udpSocket.SendRoutingRequest(guid, connection.ConnectionGuid, true);
                udpSocket.SendRoutingRequest(connection.ConnectionGuid, guid, true);
                currentConnection = connection;
                if (AssignmentTakenForHandlingEvent != null)
                    AssignmentTakenForHandlingEvent();
            }
            catch(TimeoutException e)
            {
                Debug.WriteLine("Timed out in processasiggment: " + e.Message);
            }
            catch(Exception e)
            {
                Debug.WriteLine("Error in processing assignment: " + e.Message);
            }
        }

        /// <summary>
        /// The function makes a new thread to send a message to server so it won't block ui thread.
        /// </summary>
        /// <param name="message">Message to be send.</param>
        public void SendTextMessage(String message)
        {
            Thread thread = new Thread(SendMessage);
            thread.Start(message);
        }

        /// <summary>
        /// The function sends a message to the server.
        /// </summary>
        /// <param name="message">The message to be send.</param>
        private void SendMessage(object message)
        {
            client.SendTextMessage(userConnection, currentConnection, new TextMessageDto() { Content = (String)message });
        }

        /// <summary>
        /// Requests unprocessing a assignment from server. CurrentConnection to null.
        /// </summary>
        /// <param name="assignment">.</param>
        internal void UnProcessAssignment(object assignment)
        {
            ConnectionDto connection = connectionDtos.First((connect => connect.ConnectionGuid.Contains((assignment as Assignment).Guid)));
            if (connection == null)
                return;
            try
            {
                client.MarkProcessedCloseConnection(userConnection, connection);
                udpSocket.SendRoutingRequest(guid, connection.ConnectionGuid, false);
                udpSocket.SendRoutingRequest(connection.ConnectionGuid, guid, false);
                currentConnection = null;
            }
            catch(TimeoutException e)
            {
                Debug.WriteLine("Timed out in unprocess assigment: " + e.Message);
            }
            catch(System.ServiceModel.FaultException e)
            {
                Debug.WriteLine(e.Message);
            }
        }

        /// <summary>
        /// The function makes a new thread to request audio video so it won't block the ui thread.
        /// </summary>
        public void RequestAudioVideoMedia()
        {
            Thread thread = new Thread(RequestAudioVideoMediaThread);
            thread.Start(false);
        }
        /// <summary>
        /// The function makes a new thread to request audio so it won't block the ui thread.
        /// </summary>
        public void RequestAudioMedia()
        {
            Thread thread = new Thread(RequestAudioVideoMediaThread);
            thread.Start(true);
        }

        /// <summary>
        /// Makes request to server for audio and video with hardcoded specs in exampleMediaConfiguration.
        /// </summary>
        private void RequestAudioVideoMediaThread(object audioOnly)
        {
            MediaConfigurationDto exampleMediaConfiguration = new MediaConfigurationDto();
            exampleMediaConfiguration.AudioCompressionQuality = 4;
            exampleMediaConfiguration.EnableAudio = true;
            if (exampleMediaConfiguration.EnablePicture = !(bool)audioOnly)
            {
                exampleMediaConfiguration.PictureCompressionQuality = 30;
                exampleMediaConfiguration.PictureFps = 2F;
                exampleMediaConfiguration.PictureResolution = 3;
            }
            
            try
            {
                client.RequestMediaUpstreaming(userConnection, currentConnection, exampleMediaConfiguration);
            }
            catch(Exception e)
            {
                Debug.WriteLine("Error in requesting mediaupstream: " + e.Message);
            }
        }

        /// <summary>
        /// The function makes a new thread to request cancel of the audio and video so it won't block the ui thread.
        /// </summary>
        public void CancelAudioVideoMedia()
        {
            Thread thread = new Thread(CancelAudioVideoMediaThread);
            thread.Start(false);      
        }
        /// <summary>
        /// The function makes a new thread to request cancel of the picture so it won't block the ui thread.
        /// </summary>
        public void CancelOnlyPicture()
        {
            Thread thread = new Thread(CancelAudioVideoMediaThread);
            thread.Start(true);   
        }

        /// <summary>
        /// Request cancel to audio and video from server. It is done by mediaConfigurationdto and setting enableaudio and
        /// enablepicture to false.
        /// </summary>
        /// <param name="onlyPicture">Bool if its only picture that need ending.</param>
        private void CancelAudioVideoMediaThread(object onlyPicture)
        {
            MediaConfigurationDto exampleMediaConfiguration = new MediaConfigurationDto();
            exampleMediaConfiguration.EnableAudio = ((bool)onlyPicture)?true:false;
            exampleMediaConfiguration.EnablePicture = false;
            try
            {
                client.RequestMediaUpstreaming(userConnection, currentConnection, exampleMediaConfiguration);
            }
            catch (Exception) { }
        }

        /// <author>Ilkka Rautiainen</author>
        /// <summary>
        /// The function sends a keepalive message to the server
        /// </summary>
        /// <param name="interval">The ping interval in seconds.</param>
        /// <returns>task that sends keepalive messages to the server.</returns>
        public async Task PingAsync(int interval)
        {
            await client.PingAsync(interval);
        }
    }
}