private static async Task SendReadyNotificationToViewers()
{
if (Conductor.ArgDict.ContainsKey("relaunch"))
{
Logger.Write($"Resuming after relaunch.");
var viewersString = Conductor.ArgDict["viewers"];
var viewerIDs = viewersString.Split(",".ToCharArray());
await CasterSocket.NotifyViewersRelaunchedScreenCasterReady(viewerIDs);
}
else
{
await CasterSocket.NotifyRequesterUnattendedReady(Conductor.RequesterID);
}
}
public static void Main(string[] args)
{
try
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
CursorIconWatcher = new CursorIconWatcher(Conductor);
var screenCaster = new WinScreenCaster(CursorIconWatcher);
var clipboardService = new WinClipboardService();
var casterSocket = new CasterSocket(new WinInput(), screenCaster, new WinAudioCapturer(), clipboardService);
Conductor = new Conductor(casterSocket, screenCaster);
Conductor.ProcessArgs(args);
Conductor.Connect().ContinueWith(async(task) =>
{
await Conductor.CasterSocket.SendDeviceInfo(Conductor.ServiceID, Environment.MachineName, Conductor.DeviceID);
if (Win32Interop.GetCurrentDesktop(out var currentDesktopName))
{
Logger.Write($"Setting initial desktop to {currentDesktopName}.");
if (Win32Interop.SwitchToInputDesktop())
{
CurrentDesktopName = currentDesktopName;
}
else
{
Logger.Write("Failed to set initial desktop.");
}
}
else
{
Logger.Write("Failed to get initial desktop name.");
}
await CheckForRelaunch();
Conductor.IdleTimer = new IdleTimer(Conductor.Viewers);
Conductor.IdleTimer.Start();
CursorIconWatcher.OnChange += CursorIconWatcher_OnChange;
clipboardService.BeginWatching();
await HandleConnection(Conductor);
});
Thread.Sleep(Timeout.Infinite);
}
catch (Exception ex)
{
Logger.Write(ex);
throw;
}
}
public Viewer(CasterSocket casterSocket,
IScreenCapturer screenCapturer,
IClipboardService clipboardService,
IWebRtcSessionFactory webRtcSessionFactory,
IAudioCapturer audioCapturer)
{
Capturer = screenCapturer;
CasterSocket = casterSocket;
WebRtcSessionFactory = webRtcSessionFactory;
EncoderParams = new EncoderParameters();
ImageQuality = defaultImageQuality;
ClipboardService = clipboardService;
ClipboardService.ClipboardTextChanged += ClipboardService_ClipboardTextChanged;
AudioCapturer = audioCapturer;
AudioCapturer.AudioSampleReady += AudioCapturer_AudioSampleReady;
}
public MainWindowViewModel()
{
Current = this;
if (!OSUtils.IsLinux)
{
return;
}
var screenCaster = new LinuxScreenCaster();
var casterSocket = new CasterSocket(new X11Input(), screenCaster, new LinuxAudioCapturer(), new LinuxClipboardService());
Conductor = new Conductor(casterSocket, screenCaster);
Conductor.SessionIDChanged += SessionIDChanged;
Conductor.ViewerRemoved += ViewerRemoved;
Conductor.ViewerAdded += ViewerAdded;
Conductor.ScreenCastRequested += ScreenCastRequested;
}
private async Task InitializeWebRtc(Viewer viewer, CasterSocket casterSocket)
{
try
{
viewer.RtcSession = new WebRtcSession();
viewer.RtcSession.LocalSdpReady += async(sender, sdp) =>
{
await casterSocket.SendRtcOfferToBrowser(sdp, viewer.ViewerConnectionID);
};
viewer.RtcSession.IceCandidateReady += async(sender, args) =>
{
await casterSocket.SendIceCandidateToBrowser(args.candidate, args.sdpMlineIndex, args.sdpMid, viewer.ViewerConnectionID);
};
await viewer.RtcSession.Init();
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
public MainWindowViewModel()
{
Current = this;
CursorIconWatcher = new CursorIconWatcher(Conductor);
CursorIconWatcher.OnChange += CursorIconWatcher_OnChange;
var screenCaster = new WinScreenCaster(CursorIconWatcher);
var clipboardService = new WinClipboardService();
clipboardService.BeginWatching();
var casterSocket = new CasterSocket(new WinInput(), screenCaster, new WinAudioCapturer(), clipboardService);
Conductor = new Conductor(casterSocket, screenCaster);
Conductor.SessionIDChanged += SessionIDChanged;
Conductor.ViewerRemoved += ViewerRemoved;
Conductor.ViewerAdded += ViewerAdded;
Conductor.ScreenCastRequested += ScreenCastRequested;
}
public async Task InitializeWebRtc()
{
try
{
var iceServers = await CasterSocket.GetIceServers();
RtcSession = WebRtcSessionFactory.GetNewSession(this);
RtcSession.LocalSdpReady += async(sender, sdp) =>
{
await CasterSocket.SendRtcOfferToBrowser(sdp.Content, ViewerConnectionID, iceServers);
};
RtcSession.IceCandidateReady += async(sender, candidate) =>
{
await CasterSocket.SendIceCandidateToBrowser(candidate.Content, candidate.SdpMlineIndex, candidate.SdpMid, ViewerConnectionID);
};
await RtcSession.Init(iceServers);
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
public async Task SendScreenSize(int width, int height)
{
await SendToViewer(() => RtcSession.SendScreenSize(width, height),
() => CasterSocket.SendScreenSize(width, height, ViewerConnectionID));
}
public static async Task Main(string[] args)
{
try
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
BuildServices();
Conductor = Services.GetRequiredService <Conductor>();
CasterSocket = Services.GetRequiredService <ICasterSocket>();
Conductor.ProcessArgs(args);
SystemEvents.SessionEnding += async(s, e) =>
{
if (e.Reason == SessionEndReasons.SystemShutdown)
{
await CasterSocket.DisconnectAllViewers();
}
};
var deviceInitService = Services.GetRequiredService <IDeviceInitService>();
var activationUri = Services.GetRequiredService <IClickOnceService>().GetActivationUri();
if (Uri.TryCreate(activationUri, UriKind.Absolute, out var result))
{
var host = $"{result.Scheme}://{result.Authority}";
if (!string.IsNullOrWhiteSpace(host))
{
Conductor.UpdateHost(host);
using var httpClient = new HttpClient();
try
{
var url = $"{host.TrimEnd('/')}/api/branding";
var query = HttpUtility.ParseQueryString(result.Query);
if (query?.AllKeys?.Contains("organizationid") == true)
{
url += $"?organizationId={query["organizationid"]}";
Conductor.UpdateOrganizationId(query["organizationid"]);
}
var branding = await httpClient.GetFromJsonAsync <BrandingInfo>(url).ConfigureAwait(false);
if (branding != null)
{
deviceInitService.SetBrandingInfo(branding);
}
}
catch { }
}
}
await deviceInitService.GetInitParams().ConfigureAwait(false);
if (Conductor.Mode == Core.Enums.AppMode.Chat)
{
StartUiThreads(false);
_ = Task.Run(async() =>
{
var chatService = Services.GetRequiredService <IChatClientService>();
await chatService.StartChat(Conductor.RequesterID, Conductor.OrganizationName);
});
}
else if (Conductor.Mode == Core.Enums.AppMode.Unattended)
{
StartUiThreads(false);
App.Current.Dispatcher.Invoke(() =>
{
App.Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;
});
_ = Task.Run(StartScreenCasting);
}
else
{
StartUiThreads(true);
}
WaitForAppExit();
}
catch (Exception ex)
{
Logger.Write(ex);
throw;
}
}
public async Task SendScreenData(string selectedScreen, string[] displayNames)
{
await SendToViewer(() => RtcSession.SendScreenData(selectedScreen, displayNames),
() => CasterSocket.SendScreenData(selectedScreen, displayNames, ViewerConnectionID));
}
public async Task ParseMessage(byte[] message)
{
try
{
var baseDto = MessagePackSerializer.Deserialize <BinaryDtoBase>(message);
switch (baseDto.DtoType)
{
case BinaryDtoType.MouseMove:
case BinaryDtoType.MouseDown:
case BinaryDtoType.MouseUp:
case BinaryDtoType.Tap:
case BinaryDtoType.MouseWheel:
case BinaryDtoType.KeyDown:
case BinaryDtoType.KeyUp:
case BinaryDtoType.CtrlAltDel:
case BinaryDtoType.ToggleBlockInput:
case BinaryDtoType.ClipboardTransfer:
case BinaryDtoType.KeyPress:
{
if (!Viewer.HasControl)
{
return;
}
}
break;
default:
break;
}
switch (baseDto.DtoType)
{
case BinaryDtoType.SelectScreen:
SelectScreen(message);
break;
case BinaryDtoType.MouseMove:
MouseMove(message);
break;
case BinaryDtoType.MouseDown:
MouseDown(message);
break;
case BinaryDtoType.MouseUp:
MouseUp(message);
break;
case BinaryDtoType.Tap:
Tap(message);
break;
case BinaryDtoType.MouseWheel:
MouseWheel(message);
break;
case BinaryDtoType.KeyDown:
KeyDown(message);
break;
case BinaryDtoType.KeyUp:
KeyUp(message);
break;
case BinaryDtoType.CtrlAltDel:
await CasterSocket.SendCtrlAltDel();
break;
case BinaryDtoType.AutoQualityAdjust:
SetAutoQualityAdjust(message);
break;
case BinaryDtoType.ToggleAudio:
ToggleAudio(message);
break;
case BinaryDtoType.ToggleBlockInput:
ToggleBlockInput(message);
break;
case BinaryDtoType.ClipboardTransfer:
ClipboardTransfer(message);
break;
case BinaryDtoType.KeyPress:
await KeyPress(message);
break;
case BinaryDtoType.QualityChange:
QualityChange(message);
break;
case BinaryDtoType.File:
await DownloadFile(message);
break;
default:
break;
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
public async Task SendCursorChange(CursorInfo cursorInfo)
{
await SendToViewer(() => RtcSession.SendCursorChange(cursorInfo),
() => CasterSocket.SendCursorChange(cursorInfo, ViewerConnectionID));
}
public async Task SendMachineName(string machineName)
{
await SendToViewer(() => RtcSession.SendMachineName(machineName),
() => CasterSocket.SendMachineName(machineName, ViewerConnectionID));
}
public async Task SendClipboardText(string clipboardText)
{
await SendToViewer(() => RtcSession.SendClipboardText(clipboardText),
() => CasterSocket.SendClipboardText(clipboardText, ViewerConnectionID));
}
public async Task SendAudioSample(byte[] audioSample)
{
await SendToViewer(() => RtcSession.SendAudioSample(audioSample),
() => CasterSocket.SendAudioSample(audioSample, ViewerConnectionID));
}
public async Task SendScreenSize(int width, int height, string viewerID)
{
await SendToViewer(() => RtcSession.SendScreenSize(width, height),
() => CasterSocket.SendScreenSize(width, height, viewerID));
}
public void SetMessageHandlers(IKeyboardMouseInput keyboardMouse)
{
CasterSocket = new CasterSocket(Connection, this, keyboardMouse);
}
public async Task Connect()
{
await CasterSocket.Connect(Host);
}
