mirrors/Remotely
3
0
Fork 0
mirror of https://github.com/immense/Remotely.git synced 2025-10-26 11:27:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactored outgoing messages.

Browse Source
This commit is contained in:
Jared Goodwin 2019-04-10 05:59:08 -07:00
parent 38f0b324f7
commit c824e8bfde
8 changed files with 319 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Remotely_Desktop/ViewModels/MainWindowViewModel.cs
View File

@ -104,8 +104,8 @@ namespace Remotely_Desktop.ViewModels
}
Conductor.SetMessageHandlers(new WinInput());
await Conductor.OutgoingMessages.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName);
await Conductor.OutgoingMessages.GetSessionID();
await Conductor.CasterSocket.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName);
await Conductor.CasterSocket.GetSessionID();
}
public void PromptForHostName()
@ -140,15 +140,15 @@ namespace Remotely_Desktop.ViewModels
foreach (Viewer viewer in viewerList)
{
viewer.DisconnectRequested = true;
await Conductor.OutgoingMessages.SendViewerRemoved(viewer.ViewerConnectionID);
await Conductor.CasterSocket.SendViewerRemoved(viewer.ViewerConnectionID);
}
}
private async void CursorIconWatcher_OnChange(object sender, CursorInfo cursor)
{
if (Conductor?.OutgoingMessages != null)
if (Conductor?.CasterSocket != null)
{
await Conductor?.OutgoingMessages?.SendCursorChange(cursor, Conductor.Viewers.Keys.ToList());
await Conductor?.CasterSocket?.SendCursorChange(cursor, Conductor.Viewers.Keys.ToList());
}
}
private void ScreenCastRequested(object sender, ScreenCastRequest screenCastRequest)
@ -178,7 +178,7 @@ namespace Remotely_Desktop.ViewModels
Logger.Write(ex);
capturer = new BitBltCapture();
}
await Conductor.OutgoingMessages.SendCursorChange(CursorIconWatcher.GetCurrentCursor(), new List<string>() { screenCastRequest.ViewerID });
await Conductor.CasterSocket.SendCursorChange(CursorIconWatcher.GetCurrentCursor(), new List<string>() { screenCastRequest.ViewerID });
ScreenCaster.BeginScreenCasting(screenCastRequest.ViewerID, screenCastRequest.RequesterName, capturer, Conductor);
});
}

8
Remotely_ScreenCast.Core/Capture/ScreenCaster.cs
View File

@ -45,16 +45,16 @@ namespace Remotely_ScreenCast.Core.Capture
conductor.InvokeViewerAdded(viewer);
}
await conductor.OutgoingMessages.SendScreenCount(
await conductor.CasterSocket.SendScreenCount(
capturer.SelectedScreen,
capturer.GetScreenCount(),
viewerID);
await conductor.OutgoingMessages.SendScreenSize(capturer.CurrentScreenBounds.Width, capturer.CurrentScreenBounds.Height, viewerID);
await conductor.CasterSocket.SendScreenSize(capturer.CurrentScreenBounds.Width, capturer.CurrentScreenBounds.Height, viewerID);
capturer.ScreenChanged += async (sender, bounds) =>
{
await conductor.OutgoingMessages.SendScreenSize(bounds.Width, bounds.Height, viewerID);
await conductor.CasterSocket.SendScreenSize(bounds.Width, bounds.Height, viewerID);
};
// TODO: SetThradDesktop causes issues with input after switching.
@ -123,7 +123,7 @@ namespace Remotely_ScreenCast.Core.Capture
if (encodedImageBytes?.Length > 0)
{
await conductor.OutgoingMessages.SendScreenCapture(encodedImageBytes, viewerID, diffArea.Left, diffArea.Top, diffArea.Width, diffArea.Height, DateTime.UtcNow);
await conductor.CasterSocket.SendScreenCapture(encodedImageBytes, viewerID, diffArea.Left, diffArea.Top, diffArea.Width, diffArea.Height, DateTime.UtcNow);
viewer.PendingFrames++;
}
// TODO: Even after disposing of the bitmap, GC doesn't collect in time. Memory usage soars quickly.

6
Remotely_ScreenCast.Core/Conductor.cs
View File

@ -32,7 +32,7 @@ namespace Remotely_ScreenCast.Core
public string CurrentDesktopName { get; set; }
public string Host { get; private set; }
public AppMode Mode { get; private set; }
public OutgoingMessages OutgoingMessages { get; private set; }
public CasterSocket CasterSocket { get; private set; }
public string RequesterID { get; private set; }
public string ServiceID { get; private set; }
public ConcurrentDictionary<string, Viewer> Viewers { get; } = new ConcurrentDictionary<string, Viewer>();
@ -78,9 +78,7 @@ namespace Remotely_ScreenCast.Core
public void SetMessageHandlers(IKeyboardMouseInput keyboardMouse)
{
OutgoingMessages = new OutgoingMessages(Connection);
MessageHandlers.ApplyConnectionHandlers(Connection, this, keyboardMouse);
CasterSocket = new CasterSocket(Connection, this, keyboardMouse);
}
public void StartWaitForViewerTimer()

297
Remotely_ScreenCast.Core/Sockets/CasterSocket.cs Normal file
View File

@ -0,0 +1,297 @@
using Microsoft.AspNetCore.SignalR.Client;
using Remotely_Shared.Models;
using Remotely_ScreenCast.Core.Models;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Remotely_ScreenCast.Core.Capture;
using System.Diagnostics;
using System.IO;
using System.Net;
using Remotely_ScreenCast.Core.Utilities;
using Remotely_ScreenCast.Core.Input;
namespace Remotely_ScreenCast.Core.Sockets
{
public class CasterSocket
{
public CasterSocket(HubConnection hubConnection, Conductor conductor, IKeyboardMouseInput keyboardMouseInput)
{
Connection = hubConnection;
Conductor = conductor;
KeyboardMouseInput = keyboardMouseInput;
ApplyConnectionHandlers();
}
private HubConnection Connection { get; }
public Conductor Conductor { get; }
public IKeyboardMouseInput KeyboardMouseInput { get; }
private void ApplyConnectionHandlers()
{
Connection.Closed += (ex) =>
{
Logger.Write($"Connection closed. Error: {ex.Message}");
Environment.Exit(1);
return Task.CompletedTask;
};
Connection.On("GetScreenCast", (string viewerID, string requesterName) =>
{
try
{
Conductor.InvokeScreenCastInitiated(new ScreenCastRequest() { ViewerID = viewerID, RequesterName = requesterName });
}
catch (Exception ex)
{
Logger.Write(ex);
}
});
Connection.On("RequestScreenCast", (string viewerID, string requesterName) =>
{
Conductor.InvokeScreenCastRequested(new ScreenCastRequest() { ViewerID = viewerID, RequesterName = requesterName });
});
Connection.On("KeyDown", (string key, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendKeyDown(key, viewer);
}
});
Connection.On("KeyUp", (string key, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendKeyUp(key, viewer);
}
});
Connection.On("KeyPress", async (string key, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendKeyDown(key, viewer);
await Task.Delay(1);
KeyboardMouseInput.SendKeyUp(key, viewer);
}
});
Connection.On("MouseMove", (double percentX, double percentY, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
KeyboardMouseInput.SendMouseMove(xyPercents.Item1, xyPercents.Item2, viewer);
}
});
Connection.On("MouseDown", (int button, double percentX, double percentY, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
if (button == 0)
{
KeyboardMouseInput.SendLeftMouseDown(xyPercents.Item1, xyPercents.Item2, viewer);
}
else if (button == 2)
{
KeyboardMouseInput.SendRightMouseDown(xyPercents.Item1, xyPercents.Item2, viewer);
}
}
});
Connection.On("MouseUp", (int button, double percentX, double percentY, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
if (button == 0)
{
KeyboardMouseInput.SendLeftMouseUp(xyPercents.Item1, xyPercents.Item2, viewer);
}
else if (button == 2)
{
KeyboardMouseInput.SendRightMouseUp(xyPercents.Item1, xyPercents.Item2, viewer);
}
}
});
Connection.On("MouseWheel", (double deltaX, double deltaY, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
KeyboardMouseInput.SendMouseWheel(-(int)deltaY, viewer);
}
});
Connection.On("ViewerDisconnected", async (string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.DisconnectRequested = true;
}
await Connection.InvokeAsync("ViewerDisconnected", viewerID);
Conductor.InvokeViewerRemoved(viewerID);
});
Connection.On("LatencyUpdate", (double latency, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.PendingFrames--;
viewer.Latency = latency;
}
});
Connection.On("SelectScreen", (int screenIndex, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.Capturer.SetSelectedScreen(screenIndex);
}
});
Connection.On("QualityChange", (int qualityLevel, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.ImageQuality = qualityLevel;
}
});
Connection.On("TouchDown", (string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendLeftMouseDown(point.X, point.Y);
}
});
Connection.On("LongPress", (string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendRightMouseDown(point.X, point.Y);
//Win32Interop.SendRightMouseUp(point.X, point.Y);
}
});
Connection.On("TouchMove", (double moveX, double moveY, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendMouseMove(point.X + moveX, point.Y + moveY);
}
});
Connection.On("TouchUp", (string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendLeftMouseUp(point.X, point.Y);
}
});
Connection.On("Tap", (double percentX, double percentY, string viewerID) =>
{
if (Conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
KeyboardMouseInput.SendLeftMouseDown(xyPercents.Item1, xyPercents.Item2, viewer);
KeyboardMouseInput.SendLeftMouseUp(xyPercents.Item1, xyPercents.Item2, viewer);
}
});
Connection.On("SharedFileIDs", (List<string> fileIDs) => {
fileIDs.ForEach(id =>
{
var url = $"{Conductor.Host}/API/FileSharing/{id}";
var webRequest = WebRequest.CreateHttp(url);
var response = webRequest.GetResponse();
var contentDisp = response.Headers["Content-Disposition"];
var fileName = contentDisp
.Split(";".ToCharArray())
.FirstOrDefault(x => x.Trim().StartsWith("filename"))
.Split("=".ToCharArray())[1];
var legalChars = fileName.ToCharArray().Where(x => !Path.GetInvalidFileNameChars().Any(y => x == y));
fileName = new string(legalChars.ToArray());
var dirPath = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "RemotelySharedFiles")).FullName;
var filePath = Path.Combine(dirPath, fileName);
using (var fs = new FileStream(filePath, FileMode.Create))
{
using (var rs = response.GetResponseStream())
{
rs.CopyTo(fs);
}
}
Process.Start("explorer.exe", dirPath);
});
});
Connection.On("SessionID", (string sessionID) =>
{
Conductor.InvokeSessionIDChanged(sessionID);
});
}
public async Task SendScreenSize(int width, int height, string viewerID)
{
await Connection.SendAsync("SendScreenSize", width, height, viewerID);
}
public async Task SendScreenCapture(byte[] captureBytes, string viewerID, int left, int top, int width, int height, DateTime captureTime)
{
await Connection.SendAsync("SendScreenCapture", captureBytes, viewerID, left, top, width, height, captureTime);
}
public async Task SendScreenCount(int primaryScreenIndex, int screenCount, string viewerID)
{
await Connection.SendAsync("SendScreenCountToBrowser", primaryScreenIndex, screenCount, viewerID);
}
public async Task NotifyRequesterUnattendedReady(string requesterID)
{
await Connection.SendAsync("NotifyRequesterUnattendedReady", requesterID);
}
public async Task SendCursorChange(CursorInfo cursor, List<string> viewerIDs)
{
await Connection.SendAsync("SendCursorChange", cursor, viewerIDs);
}
public async Task NotifyViewersRelaunchedScreenCasterReady(string[] viewerIDs)
{
await Connection.SendAsync("NotifyViewersRelaunchedScreenCasterReady", viewerIDs);
}
public async Task SendDeviceInfo(string serviceID, string machineName)
{
await Connection.SendAsync("ReceiveDeviceInfo", serviceID, machineName);
}
public async Task SendConnectionFailedToViewers(List<string> viewerIDs)
{
await Connection.SendAsync("SendConnectionFailedToViewers", viewerIDs);
}
public async Task GetSessionID()
{
await Connection.SendAsync("GetSessionID");
}
public async Task SendViewerRemoved(string viewerID)
{
await Connection.SendAsync("SendViewerRemoved", viewerID);
}
}
}

235
Remotely_ScreenCast.Core/Sockets/MessageHandlers.cs
View File

@ -1,235 +0,0 @@
using Microsoft.AspNetCore.SignalR.Client;
using Remotely_ScreenCast.Core.Capture;
using Remotely_ScreenCast.Core.Utilities;
using Remotely_ScreenCast.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.IO;
using System.Diagnostics;
using Remotely_ScreenCast.Core.Models;
using Remotely_ScreenCast.Core.Input;
using Remotely_Shared.Models;
namespace Remotely_ScreenCast.Core.Sockets
{
public class MessageHandlers
{
public static void ApplyConnectionHandlers(HubConnection hubConnection, Conductor conductor, IKeyboardMouseInput keyboardMouse)
{
hubConnection.Closed += (ex) =>
{
Logger.Write($"Connection closed. Error: {ex.Message}");
Environment.Exit(1);
return Task.CompletedTask;
};
hubConnection.On("GetScreenCast", (string viewerID, string requesterName) =>
{
try
{
conductor.InvokeScreenCastInitiated(new ScreenCastRequest() { ViewerID = viewerID, RequesterName = requesterName });
}
catch (Exception ex)
{
Logger.Write(ex);
}
});
hubConnection.On("RequestScreenCast", (string viewerID, string requesterName) =>
{
conductor.InvokeScreenCastRequested(new ScreenCastRequest() { ViewerID = viewerID, RequesterName = requesterName });
});
hubConnection.On("KeyDown", (string key, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
keyboardMouse.SendKeyDown(key, viewer);
}
});
hubConnection.On("KeyUp", (string key, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
keyboardMouse.SendKeyUp(key, viewer);
}
});
hubConnection.On("KeyPress", async (string key, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
keyboardMouse.SendKeyDown(key, viewer);
await Task.Delay(1);
keyboardMouse.SendKeyUp(key, viewer);
}
});
hubConnection.On("MouseMove", (double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
keyboardMouse.SendMouseMove(xyPercents.Item1, xyPercents.Item2, viewer);
}
});
hubConnection.On("MouseDown", (int button, double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
if (button == 0)
{
keyboardMouse.SendLeftMouseDown(xyPercents.Item1, xyPercents.Item2, viewer);
}
else if (button == 2)
{
keyboardMouse.SendRightMouseDown(xyPercents.Item1, xyPercents.Item2, viewer);
}
}
});
hubConnection.On("MouseUp", (int button, double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
if (button == 0)
{
keyboardMouse.SendLeftMouseUp(xyPercents.Item1, xyPercents.Item2, viewer);
}
else if (button == 2)
{
keyboardMouse.SendRightMouseUp(xyPercents.Item1, xyPercents.Item2, viewer);
}
}
});
hubConnection.On("MouseWheel", (double deltaX, double deltaY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
keyboardMouse.SendMouseWheel(-(int)deltaY, viewer);
}
});
hubConnection.On("ViewerDisconnected", async (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.DisconnectRequested = true;
}
await hubConnection.InvokeAsync("ViewerDisconnected", viewerID);
conductor.InvokeViewerRemoved(viewerID);
});
hubConnection.On("LatencyUpdate", (double latency, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.PendingFrames--;
viewer.Latency = latency;
}
});
hubConnection.On("SelectScreen", (int screenIndex, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.Capturer.SetSelectedScreen(screenIndex);
}
});
hubConnection.On("QualityChange", (int qualityLevel, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer))
{
viewer.ImageQuality = qualityLevel;
}
});
hubConnection.On("TouchDown", (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendLeftMouseDown(point.X, point.Y);
}
});
hubConnection.On("LongPress", (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendRightMouseDown(point.X, point.Y);
//Win32Interop.SendRightMouseUp(point.X, point.Y);
}
});
hubConnection.On("TouchMove", (double moveX, double moveY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendMouseMove(point.X + moveX, point.Y + moveY);
}
});
hubConnection.On("TouchUp", (string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
//User32.GetCursorPos(out var point);
//Win32Interop.SendLeftMouseUp(point.X, point.Y);
}
});
hubConnection.On("Tap", (double percentX, double percentY, string viewerID) =>
{
if (conductor.Viewers.TryGetValue(viewerID, out var viewer) && viewer.HasControl)
{
var xyPercents = ScreenCaster.GetAbsolutePercentFromRelativePercent(percentX, percentY, viewer.Capturer);
keyboardMouse.SendLeftMouseDown(xyPercents.Item1, xyPercents.Item2, viewer);
keyboardMouse.SendLeftMouseUp(xyPercents.Item1, xyPercents.Item2, viewer);
}
});
hubConnection.On("SharedFileIDs", (List<string> fileIDs) => {
fileIDs.ForEach(id =>
{
var url = $"{conductor.Host}/API/FileSharing/{id}";
var webRequest = WebRequest.CreateHttp(url);
var response = webRequest.GetResponse();
var contentDisp = response.Headers["Content-Disposition"];
var fileName = contentDisp
.Split(";".ToCharArray())
.FirstOrDefault(x => x.Trim().StartsWith("filename"))
.Split("=".ToCharArray())[1];
var legalChars = fileName.ToCharArray().Where(x => !Path.GetInvalidFileNameChars().Any(y => x == y));
fileName = new string(legalChars.ToArray());
var dirPath = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), "RemotelySharedFiles")).FullName;
var filePath = Path.Combine(dirPath, fileName);
using (var fs = new FileStream(filePath, FileMode.Create))
{
using (var rs = response.GetResponseStream())
{
rs.CopyTo(fs);
}
}
Process.Start("explorer.exe", dirPath);
});
});
hubConnection.On("SessionID", (string sessionID) =>
{
conductor.InvokeSessionIDChanged(sessionID);
});
}
}
}

71
Remotely_ScreenCast.Core/Sockets/OutgoingMessages.cs
View File

@ -1,71 +0,0 @@
using Microsoft.AspNetCore.SignalR.Client;
using Remotely_Shared.Models;
using Remotely_ScreenCast.Core.Models;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Remotely_ScreenCast.Core.Sockets
{
public class OutgoingMessages
{
public OutgoingMessages(HubConnection hubConnection)
{
Connection = hubConnection;
}
private HubConnection Connection { get; }
public async Task SendScreenSize(int width, int height, string viewerID)
{
await Connection.SendAsync("SendScreenSize", width, height, viewerID);
}
public async Task SendScreenCapture(byte[] captureBytes, string viewerID, int left, int top, int width, int height, DateTime captureTime)
{
await Connection.SendAsync("SendScreenCapture", captureBytes, viewerID, left, top, width, height, captureTime);
}
public async Task SendScreenCount(int primaryScreenIndex, int screenCount, string viewerID)
{
await Connection.SendAsync("SendScreenCountToBrowser", primaryScreenIndex, screenCount, viewerID);
}
public async Task NotifyRequesterUnattendedReady(string requesterID)
{
await Connection.SendAsync("NotifyRequesterUnattendedReady", requesterID);
}
public async Task SendCursorChange(CursorInfo cursor, List<string> viewerIDs)
{
await Connection.SendAsync("SendCursorChange", cursor, viewerIDs);
}
public async Task NotifyViewersRelaunchedScreenCasterReady(string[] viewerIDs)
{
await Connection.SendAsync("NotifyViewersRelaunchedScreenCasterReady", viewerIDs);
}
public async Task SendDeviceInfo(string serviceID, string machineName)
{
await Connection.SendAsync("ReceiveDeviceInfo", serviceID, machineName);
}
public async Task SendConnectionFailedToViewers(List<string> viewerIDs)
{
await Connection.SendAsync("SendConnectionFailedToViewers", viewerIDs);
}
public async Task GetSessionID()
{
await Connection.SendAsync("GetSessionID");
}
public async Task SendViewerRemoved(string viewerID)
{
await Connection.SendAsync("SendViewerRemoved", viewerID);
}
}
}

6
Remotely_ScreenCast.Linux/Program.cs
View File

@ -27,8 +27,8 @@ namespace Remotely_ScreenCast.Linux
Conductor.Connect().Wait();
Conductor.SetMessageHandlers(new X11Input(Display));
Conductor.ScreenCastInitiated += ScreenCastInitiated;
Conductor.OutgoingMessages.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName).Wait();
Conductor.OutgoingMessages.NotifyRequesterUnattendedReady(Conductor.RequesterID).Wait();
Conductor.CasterSocket.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName).Wait();
Conductor.CasterSocket.NotifyRequesterUnattendedReady(Conductor.RequesterID).Wait();
Conductor.StartWaitForViewerTimer();
while (true)
{
@ -47,7 +47,7 @@ namespace Remotely_ScreenCast.Linux
try
{
var capturer = new X11Capture(Display);
await Conductor.OutgoingMessages.SendCursorChange(new CursorInfo(null, Point.Empty, "default"), new List<string>() { screenCastRequest.ViewerID });
await Conductor.CasterSocket.SendCursorChange(new CursorInfo(null, Point.Empty, "default"), new List<string>() { screenCastRequest.ViewerID });
ScreenCaster.BeginScreenCasting(screenCastRequest.ViewerID, screenCastRequest.RequesterName, capturer, Conductor);
}
catch (Exception ex)

14
Remotely_ScreenCast.Win/Program.cs
View File

@ -41,7 +41,7 @@ namespace Remotely_ScreenCast.Win
Conductor.ScreenCastInitiated += ScreenCastInitiated;
CursorIconWatcher = new CursorIconWatcher(Conductor);
CursorIconWatcher.OnChange += CursorIconWatcher_OnChange;
Conductor.OutgoingMessages.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName).Wait();
Conductor.CasterSocket.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName).Wait();
CheckInitialDesktop();
CheckForRelaunch();
Conductor.StartWaitForViewerTimer();
@ -62,11 +62,11 @@ namespace Remotely_ScreenCast.Win
Logger.Write($"Resuming after relaunch in desktop {Conductor.CurrentDesktopName}.");
var viewersString = Conductor.ArgDict["viewers"];
var viewerIDs = viewersString.Split(",".ToCharArray());
Conductor.OutgoingMessages.NotifyViewersRelaunchedScreenCasterReady(viewerIDs).Wait();
Conductor.CasterSocket.NotifyViewersRelaunchedScreenCasterReady(viewerIDs).Wait();
}
else
{
Conductor.OutgoingMessages.NotifyRequesterUnattendedReady(Conductor.RequesterID).Wait();
Conductor.CasterSocket.NotifyRequesterUnattendedReady(Conductor.RequesterID).Wait();
}
}
@ -90,15 +90,15 @@ namespace Remotely_ScreenCast.Win
Logger.Write(ex);
capturer = new BitBltCapture();
}
await Conductor.OutgoingMessages.SendCursorChange(CursorIconWatcher.GetCurrentCursor(), new List<string>() { screenCastRequest.ViewerID });
await Conductor.CasterSocket.SendCursorChange(CursorIconWatcher.GetCurrentCursor(), new List<string>() { screenCastRequest.ViewerID });
ScreenCaster.BeginScreenCasting(screenCastRequest.ViewerID, screenCastRequest.RequesterName, capturer, Conductor);
}
public static async void CursorIconWatcher_OnChange(object sender, CursorInfo cursor)
{
if (Conductor?.OutgoingMessages != null)
if (Conductor?.CasterSocket != null)
{
await Conductor.OutgoingMessages.SendCursorChange(cursor, Conductor.Viewers.Keys.ToList());
await Conductor.CasterSocket.SendCursorChange(cursor, Conductor.Viewers.Keys.ToList());
}
}
@ -120,7 +120,7 @@ namespace Remotely_ScreenCast.Win
if (!result)
{
Logger.Write($"Desktop switch to {desktopName} failed.");
conductor.OutgoingMessages.SendConnectionFailedToViewers(conductor.Viewers.Keys.ToList()).Wait();
conductor.CasterSocket.SendConnectionFailedToViewers(conductor.Viewers.Keys.ToList()).Wait();
}
}
await Task.Delay(100);