From b0cb465f79e4caa0e232150eb48c0e920342182b Mon Sep 17 00:00:00 2001 From: mlopezsegura <90263997+mlopezsegura@users.noreply.github.com> Date: Sat, 14 Nov 2026 14:54:49 +0100 Subject: [PATCH 1/2] Composite sessions instead of joining streams live A composite session is a session kind of its own: it joins two to four RDP sessions in one stream, each in a slot of a 2x2 grid (side by side, stacked, 2x2, one large and two small), with its own Sunshine, ports, pairing and name in Moonlight. Starting it starts the stopped members, pauses their own Sunshine, reconnects each to its slot size and launches its Sunshine in the keyboard session's Windows session, which composes them all. Stopping it gives every member back its size and Sunshine and stops the ones it started. Controller N goes to slot N. Members stay normal sessions. The dashboard gets a "+ Composite session" editor with templates and a visual grid, composite cards with a slot map, and an "In " chip on members. The live "join another session's stream" mosaic is removed. Co-Authored-By: Claude Opus 5.5 --- Core/Api/CompositeEndpoints.cs | 92 ++++ Core/Api/MosaicEndpoints.cs | 81 ---- Core/Api/SessionEndpoints.cs | 16 +- Core/Api/StreamSession.cs | 30 +- Core/Api/StreamSessionService.Composite.cs | 366 ++++++++++++++++ Core/Api/StreamSessionService.cs | 34 +- Core/wwwroot/app.js | 93 +--- Core/wwwroot/composites.js | 188 ++++++++ Core/wwwroot/index.html | 57 +++ Core/wwwroot/locales/bg.json | 49 ++- Core/wwwroot/locales/cs.json | 49 ++- Core/wwwroot/locales/de.json | 49 ++- Core/wwwroot/locales/en.json | 49 ++- Core/wwwroot/locales/en_GB.json | 49 ++- Core/wwwroot/locales/en_US.json | 49 ++- Core/wwwroot/locales/es.json | 49 ++- Core/wwwroot/locales/fr.json | 49 ++- Core/wwwroot/locales/hu.json | 49 ++- Core/wwwroot/locales/it.json | 49 ++- Core/wwwroot/locales/ja.json | 49 ++- Core/wwwroot/locales/ko.json | 49 ++- Core/wwwroot/locales/pl.json | 49 ++- Core/wwwroot/locales/pt.json | 49 ++- Core/wwwroot/locales/pt_BR.json | 49 ++- Core/wwwroot/locales/ru.json | 49 ++- Core/wwwroot/locales/sv.json | 49 ++- Core/wwwroot/locales/tr.json | 49 ++- Core/wwwroot/locales/uk.json | 49 ++- Core/wwwroot/locales/vi.json | 49 ++- Core/wwwroot/locales/zh.json | 49 ++- Core/wwwroot/locales/zh_TW.json | 49 ++- Core/wwwroot/style.css | 32 +- Program.cs | 6 +- README.md | 2 +- Services/Gamepad/GamepadSessionIsolation.cs | 44 +- Services/Localization/Locales/bg.json | 24 +- Services/Localization/Locales/cs.json | 24 +- Services/Localization/Locales/de.json | 24 +- Services/Localization/Locales/en.json | 24 +- Services/Localization/Locales/en_GB.json | 24 +- Services/Localization/Locales/en_US.json | 24 +- Services/Localization/Locales/es.json | 24 +- Services/Localization/Locales/fr.json | 24 +- Services/Localization/Locales/hu.json | 24 +- Services/Localization/Locales/it.json | 24 +- Services/Localization/Locales/ja.json | 24 +- Services/Localization/Locales/ko.json | 24 +- Services/Localization/Locales/pl.json | 24 +- Services/Localization/Locales/pt.json | 24 +- Services/Localization/Locales/pt_BR.json | 24 +- Services/Localization/Locales/ru.json | 24 +- Services/Localization/Locales/sv.json | 24 +- Services/Localization/Locales/tr.json | 24 +- Services/Localization/Locales/uk.json | 24 +- Services/Localization/Locales/vi.json | 24 +- Services/Localization/Locales/zh.json | 24 +- Services/Localization/Locales/zh_TW.json | 24 +- Services/Mosaic/MosaicLayout.cs | 58 ++- Services/Mosaic/MosaicService.cs | 405 ------------------ Services/Seats/SeatManager.cs | 4 +- docs/mosaico.md | 83 ---- docs/sesiones-compuestas.md | 94 ++++ tests/OpenStreamMS.Tests/MosaicLayoutTests.cs | 78 ++-- tests/i18n-backend.test.cjs | 4 +- 64 files changed, 1985 insertions(+), 1388 deletions(-) create mode 100644 Core/Api/CompositeEndpoints.cs delete mode 100644 Core/Api/MosaicEndpoints.cs create mode 100644 Core/Api/StreamSessionService.Composite.cs create mode 100644 Core/wwwroot/composites.js delete mode 100644 Services/Mosaic/MosaicService.cs delete mode 100644 docs/mosaico.md create mode 100644 docs/sesiones-compuestas.md diff --git a/Core/Api/CompositeEndpoints.cs b/Core/Api/CompositeEndpoints.cs new file mode 100644 index 0000000..f4fa672 --- /dev/null +++ b/Core/Api/CompositeEndpoints.cs @@ -0,0 +1,92 @@ +using Microsoft.AspNetCore.Http.HttpResults; +using OpenStreamMS.Services.Mosaic; +using OpenStreamMS.Services.Seats; + +namespace OpenStreamMS.Core.Api; + +/// Hueco de una sesión compuesta en la API. +/// Sesión RDP del hueco. +/// Parte de la pantalla: Left, Right, Top, Bottom, TopLeft, TopRight, BottomLeft o BottomRight. +public record CompositeSlotRequest(Guid Session, SeatScreenArea Area); + +/// Crear o editar una sesión compuesta. +/// Nombre (el que se ve en Moonlight). +/// De 2 a 4 huecos sin pisarse, en orden: el mando N va al hueco N. +/// Sesión del teclado, el ratón y el audio; null = la del primer hueco. +/// Ancho del stream. +/// Alto del stream. +/// Fps del stream. +/// Arrancarla con el servicio. +/// Puerto base de su Sunshine; 0 o ausente = el primero libre. +/// Protocolos de su Sunshine. +public record CompositeRequest( + string Name, + IReadOnlyList Slots, + Guid? Input = null, + int Width = 1920, + int Height = 1080, + int FrameRate = 60, + bool Enabled = false, + int SunshineStreamPort = 0, + StreamProtocol StreamProtocol = StreamProtocol.Both); + +/// Plantilla de huecos que ofrece el panel. +public record CompositeTemplate(string Id, IReadOnlyList Areas); + +/// +/// API de las sesiones compuestas. Crear y editar van aquí; arrancar, parar, borrar, logs y +/// emparejamiento son los de cualquier sesión (/api/sessions/{id}/...). +/// +public static class CompositeEndpoints +{ + public static IEndpointRouteBuilder MapCompositeApi(this IEndpointRouteBuilder app) + { + var group = app.MapGroup("/api/composites").WithTags("Composite sessions"); + + group.MapGet("/templates", () => TypedResults.Ok( + MosaicLayout.Templates.Select(t => new CompositeTemplate(t.Key, t.Value)))) + .WithName("GetCompositeTemplates") + .WithSummary("Plantillas de huecos de las sesiones compuestas"); + + group.MapPost("/", Create) + .WithName("CreateComposite") + .WithSummary("Crear una sesión compuesta") + .WithDescription(""" + Junta en un stream propio las pantallas de 2 a 4 sesiones RDP con captura RemoteIdd, + cada una en su hueco. Tiene su propio Sunshine (puertos, emparejamiento y nombre en + Moonlight). Al arrancarla se arrancan las sesiones paradas. + """); + + group.MapPut("/{id:guid}", Update) + .WithName("UpdateComposite") + .WithSummary("Editar una sesión compuesta parada"); + + return app; + } + + private static CompositeDefinition ToDefinition(CompositeRequest req) => new( + req.Name ?? "", + (req.Slots ?? []).Select(s => new CompositeSlot(s.Session, s.Area)).ToList(), + req.Input, req.Width, req.Height, req.FrameRate, req.Enabled, + req.SunshineStreamPort, req.StreamProtocol); + + private static Results, BadRequest, NotFound> Create( + CompositeRequest req, StreamSessionService svc) + { + try + { + var s = svc.CreateComposite(ToDefinition(req)); + return TypedResults.Created($"/api/sessions/{s.Id}", SessionEndpoints.ToResponse(s)); + } + catch (KeyNotFoundException) { return TypedResults.NotFound(); } + catch (InvalidOperationException ex) { return TypedResults.BadRequest(ex.Message); } + } + + private static Results, BadRequest, NotFound> Update( + Guid id, CompositeRequest req, StreamSessionService svc) + { + try { return TypedResults.Ok(SessionEndpoints.ToResponse(svc.UpdateComposite(id, ToDefinition(req)))); } + catch (KeyNotFoundException) { return TypedResults.NotFound(); } + catch (InvalidOperationException ex) { return TypedResults.BadRequest(ex.Message); } + } +} diff --git a/Core/Api/MosaicEndpoints.cs b/Core/Api/MosaicEndpoints.cs deleted file mode 100644 index da6e281..0000000 --- a/Core/Api/MosaicEndpoints.cs +++ /dev/null @@ -1,81 +0,0 @@ -using OpenStreamMS.Services.Mosaic; - -namespace OpenStreamMS.Core.Api; - -/// Sesión de OpenStreamMS. -/// Nombre de la sesión. -/// Parte de la cuadrícula que ocupa (Full, Left, Right, TopLeft…). -public record MosaicMemberDto(Guid Id, string Name, string Area); - -/// Sesión anfitriona (la que se retransmite). -/// Por orden de llegada; la primera es la anfitriona. El mando N va a la sesión N. -/// Con dos sesiones, una encima de otra en vez de una al lado de otra. -public record MosaicDto(Guid Host, List Members, bool Stacked); - -/// true: una encima de otra (arriba/abajo); false: una al lado de otra (izquierda/derecha). -public record MosaicLayoutRequest(bool Stacked); - -/// -/// Endpoints REST del mosaico (ver ). Mismo estilo que . -/// -public static class MosaicEndpoints -{ - public static IEndpointRouteBuilder MapMosaicApi(this IEndpointRouteBuilder app) - { - var group = app.MapGroup("/api/sessions/{id:guid}/mosaic").WithTags("Mosaic"); - - group.MapGet("/", (Guid id, MosaicService mosaic, StreamSessionService sessions) => - sessions.Get(id) is null ? Results.NotFound() : Results.Ok(ToDto(id, mosaic, sessions))) - .WithName("GetMosaic") - .WithSummary("Mosaico de una sesión anfitriona") - .WithDescription("Sesiones que comparten el stream de la anfitriona, por orden de llegada y con su parte de la pantalla. " + - "Sin mosaico, la lista solo tiene la anfitriona a pantalla entera."); - - group.MapPost("/{guestId:guid}", async (Guid id, Guid guestId, MosaicService mosaic, StreamSessionService sessions, CancellationToken ct) => - await Action(() => mosaic.JoinAsync(id, guestId, ct), id, mosaic, sessions)) - .WithName("JoinMosaic") - .WithSummary("Unir una sesión al mosaico") - .WithDescription(""" - Une la sesión guestId al stream de la sesión anfitriona {id} (hasta cuatro en total), en la - siguiente parte libre: 2 sesiones en mitades, 3 o 4 en cuartos. La invitada se arranca si - hace falta y su Sunshine queda en pausa. Las sesiones se reconectan al tamaño de su parte - (~1-2 s cada una). Requiere captura RemoteIdd y un cliente conectado a la anfitriona. - """); - - group.MapDelete("/{memberId:guid}", async (Guid id, Guid memberId, MosaicService mosaic, StreamSessionService sessions, CancellationToken ct) => - await Action(() => mosaic.LeaveAsync(id, memberId, ct), id, mosaic, sessions)) - .WithName("LeaveMosaic") - .WithSummary("Sacar una sesión del mosaico") - .WithDescription("Saca la sesión del mosaico: vuelve a su resolución y a servirse por su Sunshine. " + - "Sacar a la anfitriona deshace el mosaico."); - - group.MapPut("/layout", async (Guid id, MosaicLayoutRequest req, MosaicService mosaic, StreamSessionService sessions, CancellationToken ct) => - await Action(() => mosaic.SetStackedAsync(id, req.Stacked, ct), id, mosaic, sessions)) - .WithName("SetMosaicLayout") - .WithSummary("Disposición con dos sesiones") - .WithDescription("Con dos sesiones, una al lado de otra (stacked: false) o una encima de otra (stacked: true). " + - "Las dos se reconectan al tamaño de su nueva mitad. Con tres o cuatro se recuerda para cuando vuelvan a ser dos."); - - return app; - } - - private static async Task Action(Func op, Guid host, MosaicService mosaic, StreamSessionService sessions) - { - try - { - await op(); - return Results.Ok(ToDto(host, mosaic, sessions)); - } - catch (KeyNotFoundException) { return Results.NotFound(); } - catch (InvalidOperationException ex) { return Results.BadRequest(ex.Message); } - } - - private static MosaicDto ToDto(Guid host, MosaicService mosaic, StreamSessionService sessions) - { - var ids = mosaic.Members(host); - if (ids.Count == 0) ids = [host]; - var areas = MosaicLayout.Areas(ids.Count, mosaic.IsStacked(host)); - return new MosaicDto(host, ids.Select((id, i) => - new MosaicMemberDto(id, sessions.Get(id)?.Name ?? "", areas[i].ToString())).ToList(), mosaic.IsStacked(host)); - } -} diff --git a/Core/Api/SessionEndpoints.cs b/Core/Api/SessionEndpoints.cs index a46933c..80bf28a 100644 --- a/Core/Api/SessionEndpoints.cs +++ b/Core/Api/SessionEndpoints.cs @@ -257,14 +257,12 @@ public record SessionResponse( RdpCompositionMode RdpComposition = RdpCompositionMode.Smooth, /// Paso del arranque en el que falló (user, rdp, profile, unlock, sunshine); null si no hay error. string? FailedPhase = null, - /// Anfitriona del mosaico en el que está la sesión (la propia si es la anfitriona); null fuera de un mosaico. - Guid? MosaicHost = null, - /// Posición en el mosaico por orden de llegada (0 = anfitriona; el mando N va a la N). - int? MosaicIndex = null, - /// Sesiones en el mosaico de la anfitriona (solo en la anfitriona). - int? MosaicCount = null, - /// Solo en la anfitriona: con dos sesiones, una encima de otra en vez de una al lado de otra. - bool MosaicStacked = false + /// Solo en una sesión compuesta: sus huecos en orden (el mando N va al hueco N). + IReadOnlyList? Composite = null, + /// Solo en una sesión compuesta: sesión del teclado, el ratón y el audio. + Guid? CompositeInput = null, + /// En un miembro: la sesión compuesta en marcha que lo usa; null si ninguna. + Guid? CompositeOf = null ); /// Usuario dedicado o perfil osms-* que ya no usa ninguna sesión. @@ -972,5 +970,5 @@ static async Task UnpairAllClients( StreamSessionService.SteamLoginState(s), s.RdpDisplayScale, s.RdpComposition, s.ErrorMessage is null ? null : s.FailedPhase, - s.MosaicHost, s.MosaicIndex, s.MosaicCount, s.MosaicStacked); + s.Composite, s.CompositeInput, s.CompositeOf); } diff --git a/Core/Api/StreamSession.cs b/Core/Api/StreamSession.cs index 1ca5ca4..14513f1 100644 --- a/Core/Api/StreamSession.cs +++ b/Core/Api/StreamSession.cs @@ -227,14 +227,24 @@ public string GetIsolatedUser() => public int? ClientsMoonlight { get; set; } public int? ClientsWebRtc { get; set; } /// - /// Sesión anfitriona del mosaico en el que está esta sesión (la propia si es la anfitriona); - /// null fuera de un mosaico. Lo mantiene . No se persiste. - /// - public Guid? MosaicHost { get; set; } - /// Posición en el mosaico por orden de llegada (0 = anfitriona; el mando N va a la N). No se persiste. - public int? MosaicIndex { get; set; } - /// Sesiones en el mosaico, solo en la anfitriona. No se persiste. - public int? MosaicCount { get; set; } - /// Solo en la anfitriona: con dos sesiones, una encima de otra. No se persiste. - public bool MosaicStacked { get; set; } + /// Sesión compuesta: en vez de una sesión de Windows propia, junta en un stream las pantallas + /// de 2 a 4 sesiones RDP, cada una en su hueco (; ver + /// StreamSessionService.Composite.cs). Tiene su propio Sunshine (puertos, emparejamiento, + /// nombre en Moonlight). Null en las sesiones normales. + /// + public List? Composite { get; set; } + /// Solo en una compuesta: sesión que recibe teclado y ratón y de la que sale el audio. + public Guid? CompositeInput { get; set; } + /// True si es una sesión compuesta. + public bool IsComposite => Composite is not null; + /// + /// En un miembro: la sesión compuesta en marcha que lo está usando (su Sunshine propio queda + /// en pausa). Null si no está en ninguna. No se persiste. + /// + public Guid? CompositeOf { get; set; } } + +/// Hueco de una sesión compuesta: qué sesión se ve en qué parte de la pantalla. +/// Sesión RDP que se ve en el hueco. +/// Parte de la pantalla (las de la pantalla dividida de los puestos). +public sealed record CompositeSlot(Guid Session, OpenStreamMS.Services.Seats.SeatScreenArea Area); diff --git a/Core/Api/StreamSessionService.Composite.cs b/Core/Api/StreamSessionService.Composite.cs new file mode 100644 index 0000000..92fb720 --- /dev/null +++ b/Core/Api/StreamSessionService.Composite.cs @@ -0,0 +1,366 @@ +using OpenStreamMS.Core.Helpers; +using OpenStreamMS.Services; +using OpenStreamMS.Services.Localization; +using OpenStreamMS.Services.Mosaic; +using OpenStreamMS.Services.Seats; +using System.Collections.Concurrent; + +namespace OpenStreamMS.Core.Api; + +/// Lo que define una sesión compuesta (crear y editar). +/// Nombre de la compuesta (y el que publica su Sunshine). +/// Huecos con su sesión, en orden: el mando N va al hueco N. +/// Sesión que recibe teclado y ratón y de la que sale el audio; null = la del primer hueco. +/// Ancho del lienzo (la resolución que recibe el cliente). +/// Alto del lienzo. +/// Fps del stream y de las sesiones mientras están en la compuesta. +/// Arrancarla con el servicio. +/// Puerto base de su Sunshine; 0 = el primero libre. +/// Protocolos de su Sunshine. +public sealed record CompositeDefinition( + string Name, IReadOnlyList Slots, Guid? Input, + int Width, int Height, int FrameRate, bool Enabled, + int StreamPort = 0, StreamProtocol Protocol = StreamProtocol.Both); + +/// +/// Sesiones compuestas: una sesión sin Windows propio que junta en un stream las pantallas de 2 a +/// 4 sesiones RDP, cada una en su hueco. +/// +/// Al arrancarla se arrancan las sesiones paradas, se pone en pausa el Sunshine de cada una +/// (nadie más lee su pantalla), se reconectan al tamaño de su hueco y se lanza el Sunshine propio de +/// la compuesta en la sesión de Windows de , que compone +/// todas con osms-mosaic.txt (). Por eso teclado, ratón y audio +/// son los de esa sesión. +/// Al pararla, cada sesión vuelve a su tamaño y a su Sunshine, y se paran las que arrancó ella. +/// Mandos: el mando N que crea su Sunshine va a la sesión del hueco N (). +/// +/// Las sesiones siguen siendo normales: pueden estar en varias compuestas, pero solo en una en marcha. +/// +public partial class StreamSessionService +{ + private static readonly TimeSpan CompositeMemberTimeout = TimeSpan.FromSeconds(120); + + /// Miembros que arrancó cada compuesta en marcha: se paran al pararla. + private readonly ConcurrentDictionary> _compositeStarted = new(); + /// Tamaño RDP que tiene ahora cada miembro de cada compuesta, para reconectar solo lo que cambia. + private readonly ConcurrentDictionary> _compositeApplied = new(); + private int _compositeGeneration; + + /// Sube cada vez que una compuesta arranca, para o cambia la sesión de Windows de un miembro. + public int CompositeGeneration => Volatile.Read(ref _compositeGeneration); + + // ── Crear y editar ─────────────────────────────────────────────────────── + + public StreamSession CreateComposite(CompositeDefinition def) + { + var (slots, input) = ValidateComposite(null, def); + var suggested = SunshinePorts.Suggest(_sessions.Values.ToList()); + var session = new StreamSession + { + Name = def.Name.Trim(), + Composite = slots, + CompositeInput = input, + SunshineExePath = ResolveExePath(null), + RdpWidth = def.Width > 0 ? def.Width : 1920, + RdpHeight = def.Height > 0 ? def.Height : 1080, + RdpFrameRate = NormalizeRdpFrameRate(def.FrameRate), + Enabled = def.Enabled, + Capture = "remoteidd", + StreamProtocol = def.Protocol, + SunshineStreamPort = def.StreamPort > 0 ? def.StreamPort : suggested.SunshineStreamPort, + WebRtcPort = suggested.WebRtcPort, + WebRtcMediaPortMin = suggested.WebRtcMediaPortMin, + WebRtcMediaPortMax = suggested.WebRtcMediaPortMax, + }; + EnsurePortsAvailable(session, _sessions.Values); + _sessions[session.Id] = session; + Logger.Log($"[SessionService] Sesión compuesta creada: '{session.Name}' ({session.Id}) con " + + string.Join(", ", slots.Select(s => $"{_sessions[s.Session].Name} ({s.Area})"))); + SaveSessions(); + return session; + } + + /// Cambia una compuesta parada (en marcha habría que recolocar sesiones con clientes conectados). + public StreamSession UpdateComposite(Guid id, CompositeDefinition def) + { + var session = RequireSession(id); + if (!session.IsComposite) throw new KeyNotFoundException(); + if (session.State is SessionState.Starting or SessionState.Running or SessionState.Stopping) + throw new InvalidOperationException(RequestCulture.T("error.stopSession")); + + var (slots, input) = ValidateComposite(id, def); + session.Name = def.Name.Trim(); + session.Composite = slots; + session.CompositeInput = input; + session.RdpWidth = def.Width > 0 ? def.Width : session.RdpWidth; + session.RdpHeight = def.Height > 0 ? def.Height : session.RdpHeight; + session.RdpFrameRate = NormalizeRdpFrameRate(def.FrameRate); + session.Enabled = def.Enabled; + session.StreamProtocol = def.Protocol; + if (def.StreamPort > 0) session.SunshineStreamPort = def.StreamPort; + EnsurePortsAvailable(session, _sessions.Values); + _sunshine.TryRemove(id, out _); // el siguiente arranque escribe la configuración nueva + Logger.Log($"[{session.Name}] Sesión compuesta modificada.", id); + SaveSessions(); + return session; + } + + private (List Slots, Guid Input) ValidateComposite(Guid? selfId, CompositeDefinition def) + { + if (string.IsNullOrWhiteSpace(def.Name)) + throw new InvalidOperationException(RequestCulture.T("error.compositeName")); + var slots = def.Slots.Where(s => s.Session != Guid.Empty).ToList(); + if (slots.Count < MosaicLayout.MinMembers || slots.Count > MosaicLayout.MaxMembers) + throw new InvalidOperationException(RequestCulture.T("error.compositeCount")); + if (slots.Select(s => s.Session).Distinct().Count() != slots.Count) + throw new InvalidOperationException(RequestCulture.T("error.compositeRepeated")); + if (!MosaicLayout.Disjoint(slots.Select(s => s.Area))) + throw new InvalidOperationException(RequestCulture.T("error.compositeOverlap")); + + foreach (var slot in slots) + { + if (!_sessions.TryGetValue(slot.Session, out var member) || member.Id == selfId) + throw new KeyNotFoundException(); + if (member.Local || member.IsComposite || !WantsRemoteIdd(member)) + throw new InvalidOperationException(RequestCulture.T("error.compositeMember", member.Name)); + } + var input = def.Input is { } i && slots.Any(s => s.Session == i) ? i : slots[0].Session; + return (slots, input); + } + + /// Compuestas que usan la sesión . + private IEnumerable CompositesUsing(Guid id) => + _sessions.Values.Where(s => s.Composite?.Any(slot => slot.Session == id) == true); + + // ── Arrancar y parar ───────────────────────────────────────────────────── + + /// Arranque de una compuesta (desde ). Si falla, deja los miembros como estaban. + private void StartComposite(StreamSession c) + { + var slots = c.Composite!; + var members = slots.Select(s => _sessions.TryGetValue(s.Session, out var m) ? m + : throw new InvalidOperationException(RequestCulture.T("error.compositeMissing"))) + .ToList(); + + // Que ninguna esté ya ocupada: en otra compuesta, en un puesto en exclusiva o con su propio cliente. + foreach (var m in members) + { + if (m.CompositeOf is { } other && other != c.Id && _sessions.TryGetValue(other, out var o)) + throw new InvalidOperationException(RequestCulture.T("error.compositeBusy", m.Name, o.Name)); + if (IsSunshinePaused(m.Id) && m.CompositeOf != c.Id) + throw new InvalidOperationException(RequestCulture.T("error.compositeSeat", m.Name)); + if (m.ClientsMoonlight + m.ClientsWebRtc is > 0) + throw new InvalidOperationException(RequestCulture.T("error.compositeStreaming", m.Name)); + } + + var started = _compositeStarted.GetOrAdd(c.Id, _ => []); + var applied = _compositeApplied.GetOrAdd(c.Id, _ => new()); + try + { + c.StartPhase = "members"; + foreach (var m in members.Where(m => m.State is not (SessionState.Running or SessionState.Starting))) + { + Logger.Log($"[{c.Name}] Arrancando '{m.Name}' para la sesión compuesta…", c.Id); + Start(m.Id); + lock (started) started.Add(m.Id); + } + foreach (var m in members) WaitCompositeMember(c, m); + + foreach (var m in members) + { + PauseSunshine(m.Id, $"sesión compuesta '{c.Name}'"); + m.CompositeOf = c.Id; + applied[m.Id] = (m.RdpWidth, m.RdpHeight); + } + Interlocked.Increment(ref _compositeGeneration); + + c.StartPhase = "layout"; + ApplyComposite(c); + + var owner = _sessions[c.CompositeInput ?? slots[0].Session]; + c.RdpSessionId = owner.RdpSessionId; + c.StartPhase = "sunshine"; + var user = ResolveUser(owner); + EnsureSunshineInstance(c, user.Domain, user.Username); + var result = GetOrCreateSunshineManager(c).EnsureRunning(c.RdpSessionId); + c.SunshinePid = result.Pid; + if (result.Status == Services.Sunshine.SunshineRunStatus.LaunchFailed) + throw new Exception(result.Message ?? RequestCulture.T("error.request")); + + if (c.State != SessionState.Starting) + { + Logger.Log($"[{c.Name}] Inicio abortado (sesión detenida mientras arrancaba).", c.Id); + return; + } + c.State = SessionState.Running; + c.StartedAt = DateTime.UtcNow; + Logger.Log($"[{c.Name}] Sesión compuesta activa: {string.Join(", ", members.Select(m => m.Name))}; " + + $"teclado, ratón y audio de '{owner.Name}' (sesión de Windows {c.RdpSessionId}).", c.Id); + } + catch + { + ReleaseComposite(c); + throw; + } + } + + private void WaitCompositeMember(StreamSession c, StreamSession m) + { + var deadline = DateTime.UtcNow + CompositeMemberTimeout; + while (m.State != SessionState.Running || m.RdpSessionId == 0) + { + if (c.State != SessionState.Starting) + throw new InvalidOperationException(RequestCulture.T("error.request")); + if (m.State is SessionState.Error or SessionState.Stopped || DateTime.UtcNow > deadline) + throw new InvalidOperationException(RequestCulture.T("error.compositeMemberStart", m.Name)); + Thread.Sleep(500); + } + } + + /// + /// Deja cada miembro en marcha en su hueco: reconecta los que cambian de tamaño y escribe el + /// fichero de Sunshine (después, porque una reconexión puede cambiar la sesión de Windows). + /// + private void ApplyComposite(StreamSession c) + { + var applied = _compositeApplied.GetOrAdd(c.Id, _ => new()); + foreach (var slot in c.Composite!) + { + if (!_sessions.TryGetValue(slot.Session, out var m) || m.State != SessionState.Running || m.RdpSessionId == 0) + continue; + var target = MosaicLayout.PartSize(slot.Area, c.RdpWidth, c.RdpHeight); + if (applied.GetValueOrDefault(m.Id) == target) continue; + ReconnectRdp(m.Id, target.Width, target.Height, c.RdpFrameRate); + applied[m.Id] = target; + Logger.Log($"[{c.Name}] '{m.Name}' en el hueco {slot.Area} ({target.Width}x{target.Height}).", c.Id); + } + WriteCompositeFile(c); + Interlocked.Increment(ref _compositeGeneration); + } + + private void WriteCompositeFile(StreamSession c) + { + var parts = c.Composite! + .Select(slot => (_sessions.TryGetValue(slot.Session, out var m) && m.State == SessionState.Running ? m.RdpSessionId : 0u, slot.Area)) + .ToList(); + var path = Path.Combine(SunshineConfigDir(c.Id), MosaicLayout.FileName); + var text = MosaicLayout.Render(c.RdpWidth, c.RdpHeight, parts); + if (File.Exists(path) && File.ReadAllText(path) == text) return; + Directory.CreateDirectory(Path.GetDirectoryName(path)!); + var tmp = path + ".tmp"; + File.WriteAllText(tmp, text); + File.Move(tmp, path, overwrite: true); + } + + /// + /// Suelta los miembros de una compuesta que se para (o que no llegó a arrancar): cada uno + /// vuelve a su tamaño y a su Sunshine, y se paran los que arrancó ella. + /// + /// Reinicio de la compuesta: los miembros que arrancó siguen en marcha y siguen siendo suyos. + private void ReleaseComposite(StreamSession c, bool restarting = false) + { + try { File.Delete(Path.Combine(SunshineConfigDir(c.Id), MosaicLayout.FileName)); } + catch (Exception ex) { Logger.Warning($"[{c.Name}] No se pudo borrar {MosaicLayout.FileName}: {ex.Message}", c.Id); } + + _compositeApplied.TryRemove(c.Id, out var applied); + HashSet? started = null; + if (restarting) started = null; + else _compositeStarted.TryRemove(c.Id, out started); + foreach (var slot in c.Composite ?? []) + { + if (!_sessions.TryGetValue(slot.Session, out var m) || (m.CompositeOf is { } of && of != c.Id)) continue; + bool ownedByUs = m.CompositeOf == c.Id; + m.CompositeOf = null; + if (started is not null && started.Contains(m.Id)) + { + Logger.Log($"[{c.Name}] Parando '{m.Name}', que arrancó la sesión compuesta.", c.Id); + if (ownedByUs) ResumeSunshine(m.Id); + if (m.State is SessionState.Running or SessionState.Starting) + _ = Task.Run(() => { try { Stop(m.Id); } catch { } }); + continue; + } + if (!ownedByUs) continue; + if (m.State == SessionState.Running && applied?.GetValueOrDefault(m.Id) is { } size && + size != (m.RdpWidth, m.RdpHeight)) + { + try { ReconnectRdp(m.Id, m.RdpWidth, m.RdpHeight, m.RdpFrameRate); } + catch (Exception ex) { Logger.Warning($"[{c.Name}] '{m.Name}' no pudo volver a su resolución: {ex.Message}", c.Id); } + } + ResumeSunshine(m.Id); + } + Interlocked.Increment(ref _compositeGeneration); + } + + // ── Vigilancia (desde MonitorAll, cada 5 s) ────────────────────────────── + + /// + /// Mantiene las compuestas en marcha: si se para la sesión del teclado, se para la compuesta; + /// si cambia su sesión de Windows, su Sunshine se relanza en la nueva; un miembro que vuelve a + /// arrancar se pone otra vez en pausa y en su hueco. + /// + private void WatchComposites() + { + foreach (var c in _sessions.Values.Where(s => s.IsComposite && s.State == SessionState.Running).ToList()) + { + try + { + var ownerId = c.CompositeInput ?? c.Composite![0].Session; + if (!_sessions.TryGetValue(ownerId, out var owner) || owner.State != SessionState.Running || owner.RdpSessionId == 0) + { + Logger.Warning($"[{c.Name}] La sesión del teclado se ha parado: se para la sesión compuesta.", c.Id); + _ = Task.Run(() => { try { Stop(c.Id); } catch { } }); + continue; + } + + bool changed = false; + foreach (var slot in c.Composite!) + { + if (!_sessions.TryGetValue(slot.Session, out var m) || m.State != SessionState.Running) continue; + // Arrancó de nuevo (parada a mano y vuelta a arrancar): su Sunshine propio fuera. + if (m.CompositeOf != c.Id || m.SunshinePid != 0 || _sunshine.ContainsKey(m.Id)) + { + if (_sunshine.TryRemove(m.Id, out var mgr)) + try { mgr.Stop(); } catch { } + m.SunshinePid = 0; + PauseSunshine(m.Id, $"sesión compuesta '{c.Name}'"); + m.CompositeOf = c.Id; + if (_compositeApplied.TryGetValue(c.Id, out var applied)) applied[m.Id] = (m.RdpWidth, m.RdpHeight); + changed = true; + } + } + if (changed) ApplyComposite(c); + else WriteCompositeFile(c); // una sesión de Windows que cambió o un miembro que se paró + + if (owner.RdpSessionId != c.RdpSessionId) + { + Logger.Log($"[{c.Name}] La sesión del teclado pasó a la sesión de Windows {owner.RdpSessionId}: se relanza Sunshine.", c.Id); + RelaunchSunshine(c, "cambio de sesión de Windows"); + c.RdpSessionId = owner.RdpSessionId; + Interlocked.Increment(ref _compositeGeneration); + } + } + catch (Exception ex) + { + Logger.Warning($"[{c.Name}] Error vigilando la sesión compuesta: {ex.Message}", c.Id); + } + } + } + + // ── Mandos ─────────────────────────────────────────────────────────────── + + /// + /// Sesión a la que va el mando número que creó el Sunshine de + /// : la del hueco N si es una compuesta en + /// marcha y ese hueco tiene sesión en marcha; si no, la del teclado. Null si no es una compuesta. + /// + public Guid? CompositePadTarget(Guid creator, int index) + { + if (!_sessions.TryGetValue(creator, out var c) || !c.IsComposite || c.State != SessionState.Running) + return null; + var slots = c.Composite!; + if (index >= 0 && index < slots.Count && _sessions.TryGetValue(slots[index].Session, out var m) && + m.State == SessionState.Running && m.RdpSessionId > 0) + return m.Id; + return c.CompositeInput ?? slots[0].Session; + } +} diff --git a/Core/Api/StreamSessionService.cs b/Core/Api/StreamSessionService.cs index 3de5a93..ee8451d 100644 --- a/Core/Api/StreamSessionService.cs +++ b/Core/Api/StreamSessionService.cs @@ -19,7 +19,7 @@ namespace OpenStreamMS.Core.Api; /// Hilo-seguro; el estado de cada sesión se actualiza desde tareas en segundo plano. /// Las sesiones se persisten en sessions.json para sobrevivir reinicios del servicio. /// -public class StreamSessionService +public partial class StreamSessionService { private readonly ServiceConfig _defaultConfig; private readonly ConcurrentDictionary _sessions = new(); @@ -173,6 +173,8 @@ public bool Delete(Guid id, bool keepUser = false) if (!_sessions.TryGetValue(id, out var session)) return false; if (session.State is SessionState.Starting or SessionState.Running or SessionState.Stopping) throw new InvalidOperationException(RequestCulture.T("error.stopSession")); + if (CompositesUsing(id).FirstOrDefault() is { } composite) + throw new InvalidOperationException(RequestCulture.T("error.compositeMemberDelete", session.Name, composite.Name)); _sessions.TryRemove(id, out _); _sunshine.TryRemove(id, out _); @@ -546,7 +548,7 @@ private void DoRestart(StreamSession session) Logger.SetSessionContext(session.Id); try { - ForceStopInternal(session); + ForceStopInternal(session, restarting: true); // Pausa breve para que Windows libere el sessionId y los locks del usuario Thread.Sleep(1500); @@ -565,7 +567,7 @@ private void DoRestart(StreamSession session) /// Lógica de force-kill compartida por Stop y Restart. Mata FreeRDP, Sunshine y hace logoff /// de la sesión Windows. Siempre deja la sesión en estado Stopped al terminar. /// - private void ForceStopInternal(StreamSession session) + private void ForceStopInternal(StreamSession session, bool restarting = false) { try { @@ -588,7 +590,8 @@ private void ForceStopInternal(StreamSession session) // quien usa el PC: de ella solo se para Sunshine. if (session.RdpSessionId > 0) { - if (!session.Local && !StreamProfileSetup.LogoffSession(session.RdpSessionId)) + // La compuesta corre en la sesión de Windows de uno de sus miembros: tampoco se cierra. + if (!session.Local && !session.IsComposite && !StreamProfileSetup.LogoffSession(session.RdpSessionId)) Logger.Warning($"[{session.Name}] La sesión Windows {session.RdpSessionId} no terminó de cerrarse.", session.Id); session.RdpSessionId = 0; } @@ -608,6 +611,9 @@ private void ForceStopInternal(StreamSession session) session.FreeRdpPid = 0; } + if (session.IsComposite) + ReleaseComposite(session, restarting); + // Modo efímero: borrar el perfil del usuario aislado en segundo plano // (profsvc tarda unos segundos en descargar el hive tras el logoff) if (session.Isolated && session.IsolatedEphemeral) @@ -717,6 +723,7 @@ public void AutoStartEnabled() public void MonitorAll() { + WatchComposites(); foreach (var session in _sessions.Values.Where(s => s.State == SessionState.Running && !_sunshineRelaunching.ContainsKey(s.Id) && !_sunshinePaused.ContainsKey(s.Id))) @@ -788,7 +795,9 @@ private void SaveSessions() Local: s.Local, IsolatedUsername: s.IsolatedUsername, RdpDisplayScale: s.RdpDisplayScale, - RdpComposition: s.RdpComposition)); + RdpComposition: s.RdpComposition, + Composite: s.Composite, + CompositeInput: s.CompositeInput)); File.WriteAllText(SessionsFile, JsonSerializer.Serialize(data, JsonOpts)); SecureFile.RestrictToAdmins(SessionsFile); } @@ -852,6 +861,8 @@ private void LoadSessions() WebRtcMediaPortMin = d.WebRtcMediaPortMin, WebRtcMediaPortMax = d.WebRtcMediaPortMax, Local = d.Local, + Composite = d.Composite is { Count: > 0 } slots ? slots.ToList() : null, + CompositeInput = d.CompositeInput, State = SessionState.Stopped, }; @@ -892,6 +903,11 @@ private void DoStart(StreamSession session) StartLocal(session); return; } + if (session.IsComposite) + { + StartComposite(session); + return; + } session.StartPhase = "user"; @@ -1307,7 +1323,7 @@ private void AdoptStreamProtocolFromSunshine(StreamSession session) private static bool UsesRemoteIdd(StreamSession session) => WantsRemoteIdd(session) && RdpWrapperManager.IsRemoteIddUsable(); - /// La sesión se captura con RemoteIdd (requisito del mosaico). + /// La sesión se captura con RemoteIdd (requisito de las sesiones compuestas). public static bool CapturesWithRemoteIdd(StreamSession session) => UsesRemoteIdd(session); /// Carpeta config del Sunshine de la sesión (la de sunshine.conf). @@ -1725,5 +1741,9 @@ private record SessionData( /// Escala de la pantalla en %. 0 en sesiones anteriores = 100. int RdpDisplayScale = 100, /// Ritmo de composición. Null en sesiones anteriores = Smooth. - RdpCompositionMode? RdpComposition = null); + RdpCompositionMode? RdpComposition = null, + /// Huecos de una sesión compuesta. Null en las sesiones normales. + List? Composite = null, + /// Sesión del teclado, el ratón y el audio de una compuesta. + Guid? CompositeInput = null); } diff --git a/Core/wwwroot/app.js b/Core/wwwroot/app.js index 1557e49..63d1711 100644 --- a/Core/wwwroot/app.js +++ b/Core/wwwroot/app.js @@ -140,7 +140,7 @@ function renderSessions() { function renderCard(s) { const isRunning = s.state === 'Running'; const isBusy = s.state === 'Starting' || s.state === 'Stopping'; - const screen = s.local + const screen = s.composite ? compositeThumb(s) : s.local ? `
${uiIcon('pc')}${esc(t('card.localShort'))}
` : `
${s.rdpWidth}×${s.rdpHeight} ${s.rdpFrameRate || 60} ${esc(t('unit.fps'))}
`; @@ -161,7 +161,7 @@ function renderCard(s) { ${screen}
${esc(s.name)}
-
${s.local ? esc(t('card.localUser')) +
${s.composite ? compositeCardUser(s) : s.local ? esc(t('card.localUser')) : s.isolated ? (s.isolatedUser ? `${esc(t('card.isolatedUserNamed'))} ${esc(s.isolatedUser)}` : esc(t('card.isolatedUser'))) @@ -170,7 +170,7 @@ function renderCard(s) {
${power}
-
${protos.join('')}${sessionSeatLine(s)}${clientsChip(s)}${mosaicChip(s)}
+
${protos.join('')}${sessionSeatLine(s)}${clientsChip(s)}${compositeMemberChip(s)}
${metricsSlot(s)} ${startProgress(s)} ${rdpWarning(s)} @@ -185,7 +185,7 @@ function renderCard(s) { ${esc(t('card.autostart'))}
@@ -197,22 +197,14 @@ function sessionMenu(e, id) { const s = sessions.find(x => x.id === id); if (!s) return; const running = s.state === 'Running', busy = s.state === 'Starting' || s.state === 'Stopping'; - const btn = e.currentTarget; - const mosaic = s.mosaicHost - ? { icon: 'grid', label: t(s.mosaicHost === s.id ? 'mosaic.dissolve' : 'mosaic.leave'), run: () => leaveMosaic(s) } - : { icon: 'grid', label: t('mosaic.join'), run: () => mosaicHostMenu(btn, s), disabled: s.local || busy, hint: t('mosaic.join_disabled') }; - // Con dos sesiones, la anfitriona elige una al lado de otra o una encima de otra. - const layout = s.mosaicHost === s.id && s.mosaicCount === 2 - ? [{ icon: 'grid', label: t(s.mosaicStacked ? 'mosaic.sideBySide' : 'mosaic.stack'), run: () => setMosaicStacked(s, !s.mosaicStacked) }] - : []; openMenu(e, [ { icon: 'restart', label: t('btn.restart'), run: () => restartSession(s.id, s.name) }, - mosaic, - ...layout, { icon: 'link', label: t('ux.connect.btn'), run: () => openSunMgrModal(s.id), disabled: !running, hint: t('btn.sunshine_disabled_title') }, { icon: 'external', label: t('btn.panel'), run: () => openSunshinePanel(s.id), disabled: !running, hint: t('btn.panel_disabled_title') }, { icon: 'log', label: t('btn.log'), run: () => openLogModal(s.id, s.name) }, - { icon: 'gear', label: t('btn.settings'), run: () => openEditModal(s.id) }, + s.composite + ? { icon: 'grid', label: t('comp.edit'), run: () => openCompositeModal(s.id), disabled: running || busy, hint: t('comp.stopToEdit') } + : { icon: 'gear', label: t('btn.settings'), run: () => openEditModal(s.id) }, { sep: true }, { icon: 'trash', label: t('btn.delete'), run: () => deleteSession(s.id, s.name), danger: true, disabled: running || busy }, ]); @@ -227,74 +219,6 @@ function clientsChip(s) { n === 0 ? t('ux.clients.none') : n === 1 ? t('ux.clients.one') : t('ux.clients.many', { n }))}`; } -// ── Mosaico: hasta cuatro sesiones en el stream de una (ver MosaicService) ───── -// Partes por número de sesiones, como MosaicLayout.Areas: celdas 0 arriba-izq., 1 arriba-der., -// 2 abajo-izq., 3 abajo-der. -const MOSAIC_CELLS = { 1: [[0, 1, 2, 3]], 2: [[0, 2], [1, 3]], 3: [[0], [1], [2]], 4: [[0], [1], [2], [3]] }; -const MOSAIC_CELLS_STACKED = [[0, 1], [2, 3]]; - -function mosaicMembers(hostId) { - return sessions.filter(x => x.mosaicHost === hostId).sort((a, b) => (a.mosaicIndex ?? 0) - (b.mosaicIndex ?? 0)); -} - -// Etiqueta con un mapa 2×2: la parte de esta sesión resaltada; el título dice qué mando va a cada una. -function mosaicChip(s) { - if (!s.mosaicHost) return ''; - const members = mosaicMembers(s.mosaicHost); - const host = sessions.find(x => x.id === s.mosaicHost); - if (!host || members.length < 2) return ''; - const parts = members.length === 2 && host.mosaicStacked ? MOSAIC_CELLS_STACKED : MOSAIC_CELLS[Math.min(members.length, 4)]; - const own = parts[s.mosaicIndex ?? 0] || []; - const used = new Set(parts.flat()); - const cells = [0, 1, 2, 3].map(c => - ``).join(''); - const list = members.map((m, i) => t('mosaic.member', { n: i + 1, name: m.name })).join(' · '); - const label = s.id === host.id - ? t('mosaic.hostChip', { n: members.length }) - : t('mosaic.guestChip', { name: host.name }); - return `${esc(label)}`; -} - -// Sesiones a cuyo stream se puede unir s: en marcha, retransmitiendo (o sin dato), sin mosaico -// o anfitrionas con hueco. s no puede ser ya anfitriona de otras. -function mosaicHostMenu(btn, s) { - const hosts = sessions.filter(h => h.id !== s.id && h.state === 'Running' && !h.local && - (!h.mosaicHost || h.mosaicHost === h.id) && (h.mosaicCount || 1) < 4 && - (h.clientsMoonlight == null || h.clientsWebRtc == null || h.clientsMoonlight + h.clientsWebRtc > 0)); - if (!hosts.length) { toast(t('mosaic.noHosts'), true); return; } - // Después del clic actual: si se abre dentro de él, el clic llega al document, que cierra - // cualquier menú cuando el clic no fue dentro (el botón pulsado ya no está en la página). - // Si la tarjeta se repintó entretanto, el botón "⋯" es otro. - const anchor = () => btn.isConnected ? btn : document.querySelector(`#card-${s.id} .more-btn`) || btn; - setTimeout(() => openMenu({ stopPropagation() {}, currentTarget: anchor() }, - hosts.map(h => ({ icon: 'grid', label: t('mosaic.joinTo', { name: h.name, n: (h.mosaicCount || 1) + 1 }), run: () => joinMosaic(h, s) })))); -} - -async function joinMosaic(host, guest) { - toast(t('mosaic.joining', { name: guest.name, host: host.name })); - const res = await api('POST', `/api/sessions/${host.id}/mosaic/${guest.id}`); - if (!res) return; - if (!res.ok) { toast(await I18n.responseError(res), true); loadSessions(); return; } - toast(t('mosaic.joined', { name: guest.name, host: host.name })); - loadSessions(); -} - -async function setMosaicStacked(host, stacked) { - toast(t('mosaic.relayout')); - const res = await api('PUT', `/api/sessions/${host.id}/mosaic/layout`, { stacked }); - if (!res) return; - if (!res.ok) { toast(await I18n.responseError(res), true); return; } - loadSessions(); -} - -async function leaveMosaic(s) { - const res = await api('DELETE', `/api/sessions/${s.mosaicHost}/mosaic/${s.id}`); - if (!res) return; - if (!res.ok) { toast(await I18n.responseError(res), true); return; } - toast(t(s.mosaicHost === s.id ? 'mosaic.dissolved' : 'mosaic.left', { name: s.name })); - loadSessions(); -} - // Puesto local asociado a la sesión: su nombre y si ahora mismo la está usando. function sessionSeatLine(s) { const seat = seats.find(x => x.sessionId === s.id); @@ -563,6 +487,7 @@ async function suggestPorts() { function openEditModal(id) { const s = sessions.find(x => x.id === id); if (!s) return; + if (s.composite) { openCompositeModal(id); return; } sessEditingId = s.id; sessEditLocal = !!s.local; @@ -904,6 +829,7 @@ function handleBackdropClick(e, id) { function closeModal(id) { const close = { 'sess-modal': closeSessionModal, + 'comp-modal': closeCompositeModal, 'log-modal': closeLogModal, 'rdp-modal': closeRdpModal, 'vigem-modal': () => closeDriverModal('vigem'), @@ -1402,6 +1328,7 @@ const UI_ICONS = { users: '', link: '', pc: '', + gamepad: '', seat: '', }; diff --git a/Core/wwwroot/composites.js b/Core/wwwroot/composites.js new file mode 100644 index 0000000..a9059ca --- /dev/null +++ b/Core/wwwroot/composites.js @@ -0,0 +1,188 @@ +'use strict'; +// Sesiones compuestas: varias sesiones RDP en un mismo stream, cada una en su hueco (ver +// StreamSessionService.Composite.cs). Aquí, el editor en rejilla y lo que la compuesta y sus +// miembros enseñan en las tarjetas. + +// Plantillas: huecos en orden (el mando N va al hueco N). Las mismas que MosaicLayout.Templates. +const COMP_TEMPLATES = { + sideBySide: ['Left', 'Right'], + stacked: ['Top', 'Bottom'], + quad: ['TopLeft', 'TopRight', 'BottomLeft', 'BottomRight'], + bigLeft: ['Left', 'TopRight', 'BottomRight'], + bigTop: ['Top', 'BottomLeft', 'BottomRight'], +}; +// Posición de cada parte en una rejilla de 2×2 (grid-area: fila/columna de inicio / fin). +const COMP_AREA_GRID = { + Full: '1/1/3/3', Left: '1/1/3/2', Right: '1/2/3/3', Top: '1/1/2/3', Bottom: '2/1/3/3', + TopLeft: '1/1/2/2', TopRight: '1/2/2/3', BottomLeft: '2/1/3/2', BottomRight: '2/2/3/3', +}; +const COMP_RESOLUTIONS = [[1280, 720], [1920, 1080], [2560, 1440], [3840, 2160]]; + +let compEditingId = null; // null = compuesta nueva +let compTemplate = 'quad'; +let compSlots = []; // id de sesión por hueco ('' = vacío) + +// Sesiones que pueden ir en un hueco: RDP (no la local) y que no sean compuestas. +function compEligible() { + return sessions.filter(x => !x.local && !x.composite); +} + +function compTemplateOf(slots) { + const areas = (slots || []).map(s => s.area); + for (const [id, tpl] of Object.entries(COMP_TEMPLATES)) { + if (areas.every(a => tpl.includes(a))) return id; + } + return 'quad'; +} + +function openCompositeModal(id) { + const c = id ? sessions.find(x => x.id === id) : null; + if (c && (c.state === 'Running' || c.state === 'Starting' || c.state === 'Stopping')) { + toast(t('comp.stopToEdit'), true); + return; + } + if (!c && compEligible().length < 2) { + toast(t('comp.noEligible'), true); + return; + } + compEditingId = c ? c.id : null; + compTemplate = c ? compTemplateOf(c.composite) : 'quad'; + const areas = COMP_TEMPLATES[compTemplate]; + compSlots = areas.map(a => (c?.composite || []).find(s => s.area === a)?.session || ''); + if (!c) { + // Propuesta: las primeras sesiones elegibles, una por hueco. + compEligible().slice(0, areas.length).forEach((s, i) => { compSlots[i] = s.id; }); + } + + byId('comp-error').style.display = 'none'; + byId('comp-title').textContent = c ? t('comp.title_edit', { name: c.name }) : t('comp.title_new'); + byId('comp-submit-label').textContent = c ? t('comp.save') : t('comp.create'); + byId('comp-name').value = c ? c.name : ''; + byId('comp-res').value = c ? `${c.rdpWidth}x${c.rdpHeight}` : '1920x1080'; + if (!byId('comp-res').value) byId('comp-res').value = '1920x1080'; + byId('comp-fps').value = c ? (c.rdpFrameRate || 60) : 60; + byId('comp-enabled').checked = !!c?.enabled; + renderCompositeEditor(c?.compositeInput || ''); + show('comp-modal'); + stopRefresh(); + byId('comp-name').focus(); +} + +function closeCompositeModal() { + hide('comp-modal'); + compEditingId = null; + startRefresh(); +} + +function selectCompTemplate(id) { + const before = compSlots.filter(Boolean); + compTemplate = id; + compSlots = COMP_TEMPLATES[id].map((_, i) => before[i] || ''); + renderCompositeEditor(byId('comp-input').value); +} + +function setCompSlot(i, sessionId) { + // Una sesión solo puede ir en un hueco: si ya estaba en otro, se intercambian. + const other = compSlots.indexOf(sessionId); + if (sessionId && other >= 0 && other !== i) compSlots[other] = compSlots[i]; + compSlots[i] = sessionId; + renderCompositeEditor(byId('comp-input').value); +} + +function renderCompositeEditor(input) { + const eligible = compEligible(); + byId('comp-templates').innerHTML = Object.entries(COMP_TEMPLATES).map(([id, areas]) => ` + `).join(''); + + const areas = COMP_TEMPLATES[compTemplate]; + byId('comp-grid').innerHTML = areas.map((a, i) => { + const options = [``] + .concat(eligible.map(s => ``)); + return `
+ ${i + 1} + + ${uiIcon('gamepad')}${esc(t('comp.pad', { n: i + 1 }))} +
`; + }).join(''); + + const chosen = compSlots.filter(Boolean); + const sel = byId('comp-input'); + sel.innerHTML = chosen.map(id => { + const s = sessions.find(x => x.id === id); + return ``; + }).join(''); + sel.value = chosen.includes(input) ? input : (chosen[0] || ''); + sel.disabled = chosen.length === 0; +} + +async function submitComposite(e) { + e?.preventDefault(); + const fail = msg => { const box = byId('comp-error'); box.textContent = msg; box.style.display = ''; }; + const name = byId('comp-name').value.trim(); + if (!name) { fail(t('comp.needName')); byId('comp-name').focus(); return; } + const areas = COMP_TEMPLATES[compTemplate]; + const slots = areas.map((area, i) => ({ session: compSlots[i], area })).filter(s => s.session); + if (slots.length < 2) { fail(t('comp.needTwo')); return; } + const [width, height] = byId('comp-res').value.split('x').map(Number); + const editing = compEditingId; + const current = editing && sessions.find(x => x.id === editing); + const body = { + name, slots, + input: byId('comp-input').value || null, + width, height, + frameRate: parseInt(byId('comp-fps').value, 10) || 60, + enabled: byId('comp-enabled').checked, + sunshineStreamPort: current ? current.sunshineStreamPort : 0, + streamProtocol: current ? current.streamProtocol : 'Both', + }; + byId('comp-submit').disabled = true; + try { + const res = await api(editing ? 'PUT' : 'POST', editing ? `/api/composites/${editing}` : '/api/composites', body); + if (!res) return; + if (!res.ok) { fail(await I18n.responseError(res)); return; } + toast(editing ? t('comp.saved') : t('comp.created', { name })); + closeCompositeModal(); + loadSessions(); + } finally { + byId('comp-submit').disabled = false; + } +} + +// ── Tarjetas ──────────────────────────────────────────────────────────────── + +// Miniatura de una compuesta: la rejilla con la inicial de la sesión de cada hueco. +function compositeThumb(c) { + const cells = (c.composite || []).map((slot, i) => { + const m = sessions.find(x => x.id === slot.session); + const running = m && m.state === 'Running'; + return `${esc((m ? m.name : '?').slice(0, 1).toUpperCase())}`; + }).join(''); + return `
${cells}
`; +} + +// Línea bajo el nombre: qué sesiones junta y quién pone el teclado. +function compositeCardUser(c) { + const names = (c.composite || []).map((slot, i) => { + const m = sessions.find(x => x.id === slot.session); + return `${i + 1} ${m ? m.name : '?'}`; + }); + const input = sessions.find(x => x.id === c.compositeInput); + const title = input ? t('comp.card_title', { list: names.join(' · '), input: input.name }) : names.join(' · '); + return `${esc(t('comp.card', { n: names.length }))}`; +} + +// En un miembro de una compuesta en marcha: en qué hueco se ve y que su stream está en pausa. +function compositeMemberChip(s) { + if (!s.compositeOf) return ''; + const c = sessions.find(x => x.id === s.compositeOf); + if (!c) return ''; + const i = (c.composite || []).findIndex(slot => slot.session === s.id); + const slot = c.composite[i]; + const map = (c.composite || []).map(x => + ``).join(''); + return `` + + `${esc(t('comp.memberChip', { name: c.name }))}`; +} diff --git a/Core/wwwroot/index.html b/Core/wwwroot/index.html index 60c32b7..780937d 100644 --- a/Core/wwwroot/index.html +++ b/Core/wwwroot/index.html @@ -103,6 +103,7 @@ + @@ -515,6 +516,61 @@
Sunshine
+ + +