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 6f72b49..35c753e 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. @@ -1013,5 +1011,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 83afed3..104bfa1 100644 --- a/Core/Api/StreamSession.cs +++ b/Core/Api/StreamSession.cs @@ -236,14 +236,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..2d0c959 --- /dev/null +++ b/Core/Api/StreamSessionService.Composite.cs @@ -0,0 +1,375 @@ +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, int generation) + { + 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")); + + bool running; + lock (c.LifecycleLock) + { + // Detenida o sustituida por otra orden mientras arrancaba. + running = StartStillWanted(c, generation); + if (running) + { + c.State = SessionState.Running; + c.StartedAt = DateTime.UtcNow; + } + } + if (!running) + { + Logger.Log($"[{c.Name}] Inicio abortado (sesión detenida mientras arrancaba).", c.Id); + return; + } + 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 a807e5c..5a2953f 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(); @@ -177,6 +177,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)); // Una sesión que acabó en Error puede conservar la sesión de Windows, el cliente RDP o // Sunshine: se cierran antes de borrarla, o quedarían sin dueño (y la carpeta, bloqueada). @@ -583,7 +585,7 @@ private void DoRestart(StreamSession session, int generation) 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); @@ -611,7 +613,7 @@ private void DoRestart(StreamSession session, int generation) /// 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 { @@ -634,7 +636,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; } @@ -654,6 +657,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) @@ -770,6 +776,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))) @@ -855,7 +862,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)); var json = JsonSerializer.Serialize(data, JsonOpts); // Fichero temporal + cambio de nombre: un corte a mitad de escritura no deja // sessions.json truncado (se perderían todas las sesiones). El lock evita que dos @@ -949,6 +958,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, }; @@ -1049,6 +1060,11 @@ private void DoStartLocked(StreamSession session, int generation) StartLocal(session, generation); return; } + if (session.IsComposite) + { + StartComposite(session, generation); + return; + } session.StartPhase = "user"; @@ -1512,7 +1528,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). @@ -1930,5 +1946,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 1b23fd2..eb646d8 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); @@ -599,6 +523,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; @@ -940,6 +865,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'), @@ -1411,6 +1337,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 3aa00d0..3eba49f 100644 --- a/Core/wwwroot/index.html +++ b/Core/wwwroot/index.html @@ -103,6 +103,7 @@ + @@ -511,6 +512,61 @@
Sunshine
+ + +