1648 lines
65 KiB
C#
1648 lines
65 KiB
C#
using MBN_STOCK_WEBVIEW.Core.Playout;
|
|
using MBN_STOCK_WEBVIEW.Core.Playout.Scenes;
|
|
using MBN_STOCK_WEBVIEW.Infrastructure;
|
|
using MBN_STOCK_WEBVIEW.LegacyApplication;
|
|
using MBN_STOCK_WEBVIEW.LegacyBridge;
|
|
using MBN_STOCK_WEBVIEW.Playout;
|
|
using MBN_STOCK_WEBVIEW.Playout.Configuration;
|
|
using MBN_STOCK_WEBVIEW.Playout.Safety;
|
|
using Microsoft.UI.Xaml;
|
|
|
|
namespace MBN_STOCK_WEBVIEW.LegacyParityApp;
|
|
|
|
public sealed partial class MainWindow
|
|
{
|
|
private readonly SemaphoreSlim _playoutCommandGate = new(1, 1);
|
|
private IPlayoutEngine? _playoutEngine;
|
|
private LegacyPlayoutWorkflow? _playoutWorkflow;
|
|
private PlayoutOptions? _playoutOptions;
|
|
private MutableLegacySceneCueCompositionOptionsSource? _compositionOptions;
|
|
private MutableLegacySceneCueCompositionOptionsSource? _stagedCompositionOptions;
|
|
private string? _playoutInitializationError;
|
|
private string? _playoutInitializationWarning;
|
|
private Task? _refreshTask;
|
|
private readonly LegacyRefreshEpoch<LegacyRefreshRuntimeStatus> _refreshEpoch =
|
|
new(LegacyRefreshRuntimeStatus.Empty);
|
|
private int _playoutBusy;
|
|
private int _playoutQuarantined;
|
|
private int _playoutShutdownStarted;
|
|
private int _operatorMutationQuarantined;
|
|
|
|
private void InitializePlayoutRuntime()
|
|
{
|
|
try
|
|
{
|
|
var explicitLocalConfigurationExists = File.Exists(
|
|
PlayoutOptionsLoader.DefaultPath);
|
|
_playoutOptions = PlayoutOptionsLoader.Load(
|
|
operatorSceneDirectory: _appliedOperatorSettings.SceneDirectory,
|
|
operatorBackgroundDirectory: _appliedOperatorSettings.BackgroundDirectory,
|
|
forceSafeDryRun: IsSourceOnlyBuild);
|
|
ResetRefreshState();
|
|
var startupComposition = LegacyParityStartupCompositionResolver.Resolve(
|
|
_playoutOptions,
|
|
explicitLocalConfigurationExists);
|
|
var initialComposition = startupComposition.Composition;
|
|
_playoutInitializationWarning = startupComposition.HasWarning
|
|
? startupComposition.WarningMessage
|
|
: null;
|
|
_compositionOptions = new MutableLegacySceneCueCompositionOptionsSource(
|
|
initialComposition);
|
|
_stagedCompositionOptions = new MutableLegacySceneCueCompositionOptionsSource(
|
|
initialComposition);
|
|
_playoutEngine = PlayoutEngineFactory.Create(
|
|
_playoutOptions,
|
|
_playoutLaunchAuthorization);
|
|
_playoutEngine.StatusChanged += OnPlayoutStatusChanged;
|
|
if (_databaseRuntime is not null)
|
|
{
|
|
_playoutWorkflow = global::MBN_STOCK_WEBVIEW.LegacySceneRuntimeFactory.Create(
|
|
_playoutEngine,
|
|
_databaseRuntime.Executor,
|
|
compositionOptionsSource: _compositionOptions,
|
|
trustedManualSource: _manualNetSellStore,
|
|
trustedViSource: _manualViStore);
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
_playoutInitializationWarning = null;
|
|
_playoutInitializationError = exception is PlayoutConfigurationException
|
|
? exception.Message
|
|
: "Tornado 송출 어댑터를 초기화하지 못했습니다.";
|
|
}
|
|
}
|
|
|
|
private async Task ConnectPlayoutAsync(CancellationToken cancellationToken)
|
|
{
|
|
var engine = _playoutEngine;
|
|
if (engine is null)
|
|
{
|
|
QueueOperatorState();
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
var result = await engine.ConnectAsync(cancellationToken).ConfigureAwait(false);
|
|
if (!result.IsSuccess)
|
|
{
|
|
_playoutInitializationWarning = null;
|
|
_playoutInitializationError = result.Message;
|
|
}
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
}
|
|
catch
|
|
{
|
|
_playoutInitializationWarning = null;
|
|
_playoutInitializationError = "Tornado 송출 엔진에 연결하지 못했습니다.";
|
|
}
|
|
|
|
QueueOperatorState();
|
|
}
|
|
|
|
private void OnPlayoutStatusChanged(object? sender, PlayoutStatusChangedEventArgs args)
|
|
{
|
|
_playoutWorkflow?.ObserveEngineStatus(args.Current);
|
|
if (string.IsNullOrWhiteSpace(args.Current.PreparedSceneName) &&
|
|
string.IsNullOrWhiteSpace(args.Current.OnAirSceneName))
|
|
{
|
|
if (args.Current.State == PlayoutConnectionState.OutcomeUnknown ||
|
|
Volatile.Read(ref _playoutQuarantined) != 0)
|
|
{
|
|
StopRefreshLoop();
|
|
}
|
|
else
|
|
{
|
|
ResetRefreshState();
|
|
}
|
|
}
|
|
|
|
QueueOperatorState();
|
|
}
|
|
|
|
private async Task<LegacyOperatorSnapshot> ExecuteOperatorPlayoutAsync(
|
|
LegacyOperatorPlayoutCommand command,
|
|
CancellationToken cancellationToken,
|
|
bool gateAPrepareClaimed = false,
|
|
LegacyOperatorPlayoutRequest? gateAPrepareRequest = null)
|
|
{
|
|
if (_playoutLaunchAuthorization.IsGateA &&
|
|
(!gateAPrepareClaimed ||
|
|
command != LegacyOperatorPlayoutCommand.Prepare ||
|
|
gateAPrepareRequest is null))
|
|
{
|
|
return _controller.ReportError(
|
|
"Gate A 검증 회차에서는 승인된 5001 PREPARE 한 번만 실행할 수 있습니다.");
|
|
}
|
|
|
|
var engine = _playoutEngine;
|
|
var workflow = _playoutWorkflow;
|
|
if (engine is null || workflow is null)
|
|
{
|
|
return _controller.ReportError(
|
|
_playoutInitializationError ?? "Tornado 송출 기능을 사용할 수 없습니다.");
|
|
}
|
|
|
|
if (Volatile.Read(ref _playoutQuarantined) != 0 ||
|
|
engine.Status.State == PlayoutConnectionState.OutcomeUnknown)
|
|
{
|
|
return _controller.ReportError(
|
|
"송출 결과를 확인할 수 없는 상태입니다. PGM과 Network Monitoring을 확인한 뒤 앱을 다시 시작하세요.");
|
|
}
|
|
|
|
if (!await _playoutCommandGate.WaitAsync(0, cancellationToken).ConfigureAwait(false))
|
|
{
|
|
return _controller.ReportError("다른 송출 명령을 처리하고 있습니다.");
|
|
}
|
|
|
|
try
|
|
{
|
|
Interlocked.Exchange(ref _playoutBusy, 1);
|
|
var nextKindBefore = workflow.State.NextKind;
|
|
var pageNavigationEnabledBefore = workflow.State.IsPageNavigationEnabled;
|
|
if (engine.Status.IsTakeOutCompletionPending)
|
|
{
|
|
return _controller.ReportError(
|
|
"Tornado TAKE OUT 완료 이벤트를 기다리는 동안에는 송출 명령을 실행할 수 없습니다.");
|
|
}
|
|
|
|
if (command != LegacyOperatorPlayoutCommand.TakeOut &&
|
|
engine.Status.IsPlayCompletionPending)
|
|
{
|
|
return _controller.ReportError(
|
|
"Tornado 재생 완료 이벤트를 기다리는 중입니다. 결과가 확인될 때까지 TAKE OUT만 사용할 수 있습니다.");
|
|
}
|
|
|
|
StopRefreshLoop();
|
|
if (command is LegacyOperatorPlayoutCommand.Prepare or
|
|
LegacyOperatorPlayoutCommand.TakeIn or
|
|
LegacyOperatorPlayoutCommand.Next)
|
|
{
|
|
ApplyStagedCompositionForNextCue();
|
|
}
|
|
PlayoutResult result;
|
|
switch (command)
|
|
{
|
|
case LegacyOperatorPlayoutCommand.Prepare:
|
|
var request = gateAPrepareRequest ??
|
|
await CreateFreshPagedPlayoutRequestAsync(
|
|
workflow,
|
|
cancellationToken).ConfigureAwait(false);
|
|
result = await workflow.PrepareAsync(
|
|
request.Playlist,
|
|
request.SelectedIndexZeroBased,
|
|
cancellationToken).ConfigureAwait(false);
|
|
break;
|
|
case LegacyOperatorPlayoutCommand.TakeIn:
|
|
// MainForm.btnTake_Click always copied m_rowidx (the operator's
|
|
// candidate) to m_crow and ran ONAirMode + Play, even while another
|
|
// row was already on air. Re-read the current selection on every F8;
|
|
// a stale explicit PREPARE must never override a later row click.
|
|
var takeInRequest = await CreateFreshPagedPlayoutRequestAsync(
|
|
workflow,
|
|
cancellationToken).ConfigureAwait(false);
|
|
result = await workflow.TakeSelectedAsync(
|
|
takeInRequest.Playlist,
|
|
takeInRequest.SelectedIndexZeroBased,
|
|
cancellationToken).ConfigureAwait(false);
|
|
break;
|
|
case LegacyOperatorPlayoutCommand.Next:
|
|
var livePlaylist = _controller.CreatePlayoutRequest(
|
|
_compositionOptions!.Current.FadeDuration).Playlist;
|
|
result = await workflow.NextAsync(
|
|
livePlaylist,
|
|
cancellationToken).ConfigureAwait(false);
|
|
break;
|
|
case LegacyOperatorPlayoutCommand.TakeOut:
|
|
result = await workflow.TakeOutAsync(
|
|
PlayoutTakeOutScope.All,
|
|
cancellationToken).ConfigureAwait(false);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException(nameof(command));
|
|
}
|
|
|
|
if (result.IsSuccess &&
|
|
command != LegacyOperatorPlayoutCommand.TakeOut &&
|
|
workflow.State.CurrentEntryId is { Length: > 0 } currentEntryId &&
|
|
workflow.State.PageCount > 0)
|
|
{
|
|
// FarPoint column 5 was mutable operator state: F8/PREPARE reset a
|
|
// paged cut to 1/N, while Page NEXT left 2/N, 3/N, ... in the row.
|
|
// NEXT must not replace the independently selected F8 candidate.
|
|
_controller.ReflectSuccessfulPlayout(
|
|
currentEntryId,
|
|
workflow.State.PageIndexZeroBased,
|
|
workflow.State.PageCount,
|
|
synchronizeOperatorSelection:
|
|
command is LegacyOperatorPlayoutCommand.Prepare or
|
|
LegacyOperatorPlayoutCommand.TakeIn);
|
|
}
|
|
|
|
if (result.Code is PlayoutResultCode.OutcomeUnknown or PlayoutResultCode.TimedOut)
|
|
{
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return _controller.ReportError(
|
|
"송출 명령 결과가 불명확합니다. 명령을 반복하지 말고 PGM과 Network Monitoring을 확인하세요.");
|
|
}
|
|
|
|
if (!result.IsSuccess)
|
|
{
|
|
return _controller.ReportError(result.Message);
|
|
}
|
|
|
|
if (command == LegacyOperatorPlayoutCommand.TakeOut)
|
|
{
|
|
ResetRefreshState();
|
|
}
|
|
|
|
if (command == LegacyOperatorPlayoutCommand.TakeIn ||
|
|
command == LegacyOperatorPlayoutCommand.Next &&
|
|
nextKindBefore == LegacyWorkflowNextKind.PlaylistNext &&
|
|
!pageNavigationEnabledBefore)
|
|
{
|
|
StartRefreshLoop(workflow);
|
|
}
|
|
|
|
return _controller.ReportInformation(result.Message);
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
return _controller.ReportError("송출 요청이 취소되었습니다.");
|
|
}
|
|
catch (DatabaseOperationException exception)
|
|
{
|
|
return _controller.ReportError(exception.Message);
|
|
}
|
|
catch (Exception exception) when (
|
|
exception is LegacySceneDataException or ArgumentException or InvalidOperationException)
|
|
{
|
|
return _controller.ReportError(exception.Message);
|
|
}
|
|
catch
|
|
{
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return _controller.ReportError(
|
|
"송출 엔진 명령의 결과를 확인할 수 없습니다. 명령을 반복하지 마세요.");
|
|
}
|
|
finally
|
|
{
|
|
Interlocked.Exchange(ref _playoutBusy, 0);
|
|
_playoutCommandGate.Release();
|
|
QueueOperatorState();
|
|
}
|
|
}
|
|
|
|
private async Task<LegacyOperatorPlayoutRequest> CreateFreshPagedPlayoutRequestAsync(
|
|
LegacyPlayoutWorkflow workflow,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var fadeDuration = _compositionOptions!.Current.FadeDuration;
|
|
var request = _controller.CreatePlayoutRequest(fadeDuration);
|
|
|
|
// The first PREPARE/TAKE IN freezes the complete playlist. Resolve every
|
|
// operator PageN row from a fresh read-only DB preflight before that snapshot
|
|
// is handed to the workflow. A later F8 while PREPARED/PROGRAM reuses the
|
|
// already-frozen 1/N values and must not query a second navigation contract.
|
|
if (workflow.State.CurrentEntryId is not null)
|
|
{
|
|
return request;
|
|
}
|
|
|
|
var pagedEntries = request.Playlist
|
|
.Where(static entry => entry.PageNavigation?.PageSize.HasValue == true)
|
|
.ToArray();
|
|
if (pagedEntries.Length == 0)
|
|
{
|
|
return request;
|
|
}
|
|
|
|
var plans = await workflow.PreflightPagePlansAsync(
|
|
Array.AsReadOnly(pagedEntries),
|
|
cancellationToken).ConfigureAwait(false);
|
|
if (plans.Count != pagedEntries.Length)
|
|
{
|
|
throw new LegacySceneDataException(
|
|
"The playlist page preflight did not return every PageN entry.");
|
|
}
|
|
|
|
foreach (var plan in plans)
|
|
{
|
|
var entry = pagedEntries.SingleOrDefault(candidate =>
|
|
string.Equals(candidate.EntryId, plan.EntryId, StringComparison.Ordinal));
|
|
if (entry?.PageNavigation?.PageSize is not { } expectedPageSize ||
|
|
plan.PageSize != (int)expectedPageSize ||
|
|
plan.PageCount is < 1 or > ScenePaging.MaximumPageCount)
|
|
{
|
|
throw new LegacySceneDataException(
|
|
"The playlist page preflight does not match the operator PageN row.");
|
|
}
|
|
|
|
_controller.ReflectSuccessfulPlayout(
|
|
plan.EntryId,
|
|
pageIndexZeroBased: 0,
|
|
pageCount: plan.PageCount,
|
|
synchronizeOperatorSelection: false);
|
|
}
|
|
|
|
return _controller.CreatePlayoutRequest(fadeDuration);
|
|
}
|
|
|
|
private async Task<LegacyOperatorSnapshot> ExecuteGateAPrepareAsync(
|
|
string capability,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!_playoutLaunchAuthorization.IsGateA ||
|
|
!_playoutLaunchAuthorization.TryClaimGateAPrepare(capability))
|
|
{
|
|
return _controller.ReportError(
|
|
"Gate A PREPARE 승인이 없거나 이미 사용되었습니다.");
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!TryCreateExactGateAPrepareRequest(out var request))
|
|
{
|
|
return _controller.ReportError(
|
|
"Gate A PREPARE 직전 상태가 승인된 삼성전자 5001 page 1 조건과 일치하지 않습니다.");
|
|
}
|
|
|
|
return await ExecuteOperatorPlayoutAsync(
|
|
LegacyOperatorPlayoutCommand.Prepare,
|
|
cancellationToken,
|
|
gateAPrepareClaimed: true,
|
|
gateAPrepareRequest: request).ConfigureAwait(false);
|
|
}
|
|
finally
|
|
{
|
|
// Success, rejection, cancellation and unknown outcome all consume the
|
|
// one process-lifetime capability. There is deliberately no retry path.
|
|
_playoutLaunchAuthorization.CompleteGateAPrepare();
|
|
}
|
|
}
|
|
|
|
private bool TryCreateExactGateAPrepareRequest(
|
|
out LegacyOperatorPlayoutRequest? request)
|
|
{
|
|
request = null;
|
|
var snapshot = _controller.Current;
|
|
if (snapshot.Playlist.Count != 1 ||
|
|
_compositionOptions?.Current is not { } composition ||
|
|
composition.FadeDuration != 6 ||
|
|
composition.BackgroundKind != LegacySceneBackgroundKind.None)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var row = snapshot.Playlist[0];
|
|
if (!row.IsEnabled || !row.IsActive ||
|
|
!string.Equals(row.MarketText, "코스피", StringComparison.Ordinal) ||
|
|
!string.Equals(row.StockName, "삼성전자", StringComparison.Ordinal) ||
|
|
!string.Equals(row.GraphicType, "1열판기본", StringComparison.Ordinal) ||
|
|
!string.Equals(row.Subtype, "현재가", StringComparison.Ordinal) ||
|
|
!string.Equals(row.PageText, "1/1", StringComparison.Ordinal) ||
|
|
!string.Equals(row.StockCode, "005930", StringComparison.Ordinal))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
LegacyOperatorPlayoutRequest candidate;
|
|
try
|
|
{
|
|
candidate = _controller.CreatePlayoutRequest(6);
|
|
}
|
|
catch (InvalidOperationException)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (candidate.SelectedIndexZeroBased != 0 ||
|
|
candidate.Playlist.Count != 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var entry = candidate.Playlist[0];
|
|
var selection = entry.Selection;
|
|
if (!entry.IsEnabled ||
|
|
!string.Equals(entry.EntryId, row.RowId, StringComparison.Ordinal) ||
|
|
!string.Equals(entry.CutCode, "5001", StringComparison.Ordinal) ||
|
|
entry.FadeDuration != 6 ||
|
|
entry.PageNavigation?.IsEnabled == true ||
|
|
entry.MovingAverageSelectionSource is not null ||
|
|
selection is null ||
|
|
!string.Equals(selection.GroupCode, "코스피", StringComparison.Ordinal) ||
|
|
!string.Equals(selection.Subject, "삼성전자", StringComparison.Ordinal) ||
|
|
!string.Equals(selection.GraphicType, "1열판기본", StringComparison.Ordinal) ||
|
|
!string.Equals(selection.Subtype, "현재가", StringComparison.Ordinal) ||
|
|
!string.Equals(selection.DataCode, "005930", StringComparison.Ordinal))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
request = candidate;
|
|
return true;
|
|
}
|
|
|
|
private async Task<LegacyOperatorSnapshot> SetFadeDurationAsync(
|
|
int fadeDuration,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!_playoutLaunchAuthorization.AllowsCompositionMutation)
|
|
{
|
|
return _controller.ReportError(
|
|
"Gate A 검증 회차에서는 Fade 설정을 변경할 수 없습니다.");
|
|
}
|
|
|
|
if (fadeDuration is < 0 or > 19)
|
|
{
|
|
return _controller.ReportError("DissolveTime 값이 올바르지 않습니다.");
|
|
}
|
|
|
|
if (!await _playoutCommandGate.WaitAsync(0, cancellationToken).ConfigureAwait(false))
|
|
{
|
|
return _controller.ReportError("송출 명령 처리 중에는 Fade를 변경할 수 없습니다.");
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!CanChangeComposition())
|
|
{
|
|
return _controller.ReportError("DissolveTime은 IDLE 상태에서만 변경할 수 있습니다.");
|
|
}
|
|
|
|
var source = _compositionOptions!;
|
|
var updated = source.Current with { FadeDuration = fadeDuration };
|
|
source.Update(updated);
|
|
_stagedCompositionOptions!.Update(updated);
|
|
return _controller.ReportInformation(
|
|
$"DissolveTime {fadeDuration + 1}을 다음 PREPARE부터 적용합니다.");
|
|
}
|
|
finally
|
|
{
|
|
_playoutCommandGate.Release();
|
|
}
|
|
}
|
|
|
|
private LegacyOperatorSnapshot SelectPlaylistBoundaryAndStopRefresh(bool last)
|
|
{
|
|
// MainForm.ProcessCmdKey stopped timer1 before applying either Home or End.
|
|
// Ordinary row selection deliberately does not use this path.
|
|
StopRefreshLoop();
|
|
return _controller.SelectPlaylistBoundary(last);
|
|
}
|
|
|
|
private async Task<LegacyOperatorSnapshot> ToggleBackgroundAsync(
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!_playoutLaunchAuthorization.AllowsCompositionMutation)
|
|
{
|
|
return _controller.ReportError(
|
|
"Gate A 검증 회차에서는 배경 설정을 변경할 수 없습니다.");
|
|
}
|
|
|
|
if (!await _playoutCommandGate.WaitAsync(0, cancellationToken).ConfigureAwait(false))
|
|
{
|
|
return _controller.ReportError("송출 명령 처리 중에는 배경을 변경할 수 없습니다.");
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!CanStageBackground())
|
|
{
|
|
return _controller.ReportError(
|
|
"송출 결과가 확정되지 않은 동안에는 다음 장면 배경을 변경할 수 없습니다.");
|
|
}
|
|
|
|
var source = _stagedCompositionOptions!;
|
|
if (source.Current.BackgroundKind == LegacySceneBackgroundKind.None)
|
|
{
|
|
source.Update(PlayoutSceneCompositionFactory.CreateLegacyDefault(
|
|
_playoutOptions!,
|
|
source.Current.FadeDuration));
|
|
_playoutInitializationWarning = null;
|
|
return _controller.ReportInformation(
|
|
"기본 배경을 다음 PREPARE부터 적용합니다.");
|
|
}
|
|
|
|
source.Update(new LegacySceneCueCompositionOptions(
|
|
source.Current.FadeDuration,
|
|
LegacySceneBackgroundKind.None));
|
|
return _controller.ReportInformation("배경 사용을 해제했습니다.");
|
|
}
|
|
catch (PlayoutConfigurationException exception)
|
|
{
|
|
return _controller.ReportError(exception.Message);
|
|
}
|
|
finally
|
|
{
|
|
_playoutCommandGate.Release();
|
|
}
|
|
}
|
|
|
|
private async Task<LegacyOperatorSnapshot> ChooseBackgroundAsync(
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!_playoutLaunchAuthorization.AllowsCompositionMutation)
|
|
{
|
|
return _controller.ReportError(
|
|
"Gate A 검증 회차에서는 배경 파일을 선택할 수 없습니다.");
|
|
}
|
|
|
|
if (!await _playoutCommandGate.WaitAsync(0, cancellationToken).ConfigureAwait(false))
|
|
{
|
|
return _controller.ReportError("송출 명령 처리 중에는 배경을 변경할 수 없습니다.");
|
|
}
|
|
|
|
try
|
|
{
|
|
if (!CanStageBackground())
|
|
{
|
|
return _controller.ReportError(
|
|
"송출 결과가 확정되지 않은 동안에는 다음 장면 배경을 변경할 수 없습니다.");
|
|
}
|
|
|
|
// MainForm.btnback_Click assigns 배경\기본.vrv before opening the
|
|
// picker. Preserve that observable behavior when the trusted default is
|
|
// present, while still allowing the operator to choose another asset if it
|
|
// is not.
|
|
var source = _stagedCompositionOptions!;
|
|
try
|
|
{
|
|
source.Update(PlayoutSceneCompositionFactory.CreateLegacyDefault(
|
|
_playoutOptions!,
|
|
source.Current.FadeDuration));
|
|
_playoutInitializationWarning = null;
|
|
}
|
|
catch (PlayoutConfigurationException)
|
|
{
|
|
}
|
|
|
|
if (!PlayoutSceneCompositionFactory.TryGetTrustedBackgroundDirectory(
|
|
_playoutOptions!,
|
|
out var trustedBackgroundDirectory))
|
|
{
|
|
return _controller.ReportError(
|
|
"설정에서 사용할 배경 폴더를 먼저 지정해 주세요.");
|
|
}
|
|
|
|
var selectedPath = await PickBackgroundFileAsync(
|
|
trustedBackgroundDirectory).ConfigureAwait(false);
|
|
if (selectedPath is null)
|
|
{
|
|
return _controller.Current;
|
|
}
|
|
|
|
if (!CanStageBackground())
|
|
{
|
|
return _controller.ReportError(
|
|
"파일 선택 중 송출 상태가 바뀌어 배경 변경을 취소했습니다.");
|
|
}
|
|
|
|
source.Update(PlayoutSceneCompositionFactory.CreateOperatorSelection(
|
|
_playoutOptions!,
|
|
source.Current.FadeDuration,
|
|
selectedPath));
|
|
_playoutInitializationWarning = null;
|
|
return _controller.ReportInformation(
|
|
"선택한 배경을 다음 PREPARE부터 적용합니다.");
|
|
}
|
|
catch (Exception exception) when (
|
|
exception is ArgumentException or IOException or UnauthorizedAccessException or
|
|
PlayoutConfigurationException)
|
|
{
|
|
return _controller.ReportError(
|
|
"신뢰 배경 폴더 안의 vrv/jpg/jpeg/png 파일만 선택할 수 있습니다.");
|
|
}
|
|
finally
|
|
{
|
|
_playoutCommandGate.Release();
|
|
}
|
|
}
|
|
|
|
private bool CanChangeComposition()
|
|
{
|
|
var status = _playoutEngine?.Status;
|
|
var workflow = _playoutWorkflow?.State;
|
|
var refresh = _refreshEpoch.ReadState();
|
|
return _playoutOptions is not null && _compositionOptions is not null &&
|
|
_stagedCompositionOptions is not null &&
|
|
status is not null && workflow is not null &&
|
|
Volatile.Read(ref _playoutBusy) == 0 &&
|
|
Volatile.Read(ref _playoutQuarantined) == 0 &&
|
|
!status.IsPlayCompletionPending &&
|
|
!status.IsTakeOutCompletionPending &&
|
|
string.IsNullOrWhiteSpace(status.PreparedSceneName) &&
|
|
string.IsNullOrWhiteSpace(status.OnAirSceneName) &&
|
|
string.IsNullOrWhiteSpace(workflow.PreparedCutCode) &&
|
|
string.IsNullOrWhiteSpace(workflow.OnAirCutCode) &&
|
|
!refresh.IsActive &&
|
|
(_refreshTask is null || _refreshTask.IsCompleted);
|
|
}
|
|
|
|
private bool CanStageBackground()
|
|
{
|
|
var status = _playoutEngine?.Status;
|
|
var workflow = _playoutWorkflow?.State;
|
|
return _playoutOptions is not null && _compositionOptions is not null &&
|
|
_stagedCompositionOptions is not null && status is not null &&
|
|
workflow is not null &&
|
|
Volatile.Read(ref _playoutBusy) == 0 &&
|
|
Volatile.Read(ref _playoutQuarantined) == 0 &&
|
|
Volatile.Read(ref _playoutShutdownStarted) == 0 &&
|
|
status.State != PlayoutConnectionState.OutcomeUnknown &&
|
|
!status.IsPlayCompletionPending &&
|
|
!status.IsTakeOutCompletionPending;
|
|
}
|
|
|
|
private void ApplyStagedCompositionForNextCue()
|
|
{
|
|
var active = _compositionOptions ??
|
|
throw new InvalidOperationException("The active composition source is unavailable.");
|
|
var staged = _stagedCompositionOptions ??
|
|
throw new InvalidOperationException("The staged composition source is unavailable.");
|
|
active.Update(staged.Current);
|
|
}
|
|
|
|
private bool CanAcceptOperatorMutation(
|
|
LegacyUiIntent intent,
|
|
out string rejectionMessage)
|
|
{
|
|
var status = _playoutEngine?.Status;
|
|
var workflow = _playoutWorkflow?.State;
|
|
var refresh = _refreshEpoch.ReadState();
|
|
if (status is null || workflow is null)
|
|
{
|
|
// A disabled or unavailable playout runtime must not prevent the operator
|
|
// from composing a playlist. PREPARE will still fail closed later.
|
|
rejectionMessage = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
// A cut double-click only appends a local row at the safe playlist tail.
|
|
// Once the refresh has released the shared intent gate, that append is
|
|
// independent of the scheduler remaining active between refreshes. All
|
|
// uncertain/pending/busy states below remain fail-closed.
|
|
var isSafeCutTailAppend = intent is
|
|
LegacyCutPointerDownIntent { AllowAppend: true } or
|
|
LegacyDropSelectedCutsIntent;
|
|
// MainForm kept its Space and "all" enabled-state gestures available while
|
|
// PROGRAM was active. They only change the native operator playlist; NEXT
|
|
// stops the refresh loop before the workflow adopts those flags. Therefore
|
|
// they are independent between refresh ticks just like a safe tail append.
|
|
var isSafeProgramEnabledStateMutation = intent is
|
|
LegacySetAllPlaylistEnabledIntent or
|
|
LegacyToggleActivePlaylistEnabledIntent;
|
|
// Deleting selected rows is also independent of the refresh scheduler, but
|
|
// only after the exact current row and every selected index are checked by
|
|
// CanDeleteSelectedPlaylistTail below. The one-slot ordered UI gate keeps
|
|
// this request behind its preceding row selection without allowing repeats.
|
|
var isSafeProgramTailDelete = intent is
|
|
LegacyDeleteSelectedPlaylistRowsIntent;
|
|
// PList did not stop or replace the active scene when it created, saved,
|
|
// overwrote, or deleted a named DB playlist. These writes only persist a
|
|
// snapshot/definition and are serialized with the automatic refresh by the
|
|
// shared intent and database gates. Loading remains an idle-only structural
|
|
// replacement below.
|
|
var isSafeNamedPlaylistPersistenceMutation = intent is
|
|
LegacyCreateNamedPlaylistIntent or
|
|
LegacySaveCurrentNamedPlaylistIntent or
|
|
LegacySaveCurrentNamedPlaylistToIntent or
|
|
LegacyDeleteSelectedNamedPlaylistIntent;
|
|
var refreshAllowsMutation = isSafeCutTailAppend ||
|
|
isSafeProgramEnabledStateMutation ||
|
|
isSafeProgramTailDelete ||
|
|
isSafeNamedPlaylistPersistenceMutation ||
|
|
(!refresh.IsActive && (_refreshTask is null || _refreshTask.IsCompleted));
|
|
var runtimeAcceptsIndependentMutation = Volatile.Read(ref _playoutBusy) == 0 &&
|
|
Volatile.Read(ref _playoutQuarantined) == 0 &&
|
|
Volatile.Read(ref _playoutShutdownStarted) == 0 &&
|
|
status.State != PlayoutConnectionState.OutcomeUnknown &&
|
|
!status.IsPlayCompletionPending &&
|
|
!status.IsTakeOutCompletionPending &&
|
|
refreshAllowsMutation;
|
|
if (!runtimeAcceptsIndependentMutation)
|
|
{
|
|
rejectionMessage =
|
|
"송출 명령 처리 중이거나 결과를 확인할 수 없는 상태에서는 편성 및 운영 데이터를 변경할 수 없습니다.";
|
|
return false;
|
|
}
|
|
|
|
if (isSafeCutTailAppend &&
|
|
!CanAppendCutToPlaylistTail(status, workflow))
|
|
{
|
|
rejectionMessage =
|
|
"PROGRAM 상태에서는 현재 송출 행을 확인할 수 있을 때만 새 컷을 대기열 끝에 추가할 수 있습니다.";
|
|
return false;
|
|
}
|
|
|
|
if (RequiresIdlePlaylistMutation(intent) && !IsPlaylistMutationIdle(status, workflow))
|
|
{
|
|
rejectionMessage = intent is
|
|
LegacyLoadSelectedNamedPlaylistIntent or LegacyLoadNamedPlaylistByIdIntent
|
|
? "송출 중에는 다른 DB 재생목록으로 교체할 수 없습니다. TAKE OUT 후 다시 시도하세요."
|
|
: "송출 중에는 행 이동·마우스 개별 체크·전체 삭제를 할 수 없습니다. Space/전체 활성 체크, 새 컷 추가와 안전한 후속 행 삭제는 계속 사용할 수 있습니다.";
|
|
return false;
|
|
}
|
|
|
|
if (isSafeProgramEnabledStateMutation &&
|
|
!CanMutatePlaylistEnabledState(status, workflow))
|
|
{
|
|
rejectionMessage =
|
|
"플레이리스트 활성 체크는 대기 또는 PROGRAM 상태에서만 변경할 수 있습니다.";
|
|
return false;
|
|
}
|
|
|
|
if (intent is LegacyDeleteSelectedPlaylistRowsIntent &&
|
|
!CanDeleteSelectedPlaylistTail(status, workflow))
|
|
{
|
|
rejectionMessage =
|
|
"송출 중에는 현재 송출 행과 그 이전 행을 삭제할 수 없습니다. 현재 행 뒤의 선택 행만 삭제할 수 있습니다.";
|
|
return false;
|
|
}
|
|
|
|
rejectionMessage = string.Empty;
|
|
return true;
|
|
}
|
|
|
|
private bool CanAppendCutToPlaylistTail(
|
|
PlayoutStatus status,
|
|
LegacyPlayoutWorkflowState workflow)
|
|
{
|
|
if (IsPlaylistMutationIdle(status, workflow))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// SetPlayList in MainForm always inserted after RowCount. Keep that PROGRAM
|
|
// behavior only while the native playlist still has one exact on-air anchor;
|
|
// the newly appended row is then guaranteed to be in the future tail.
|
|
if (string.IsNullOrWhiteSpace(status.OnAirSceneName) ||
|
|
string.IsNullOrWhiteSpace(workflow.OnAirCutCode) ||
|
|
string.IsNullOrWhiteSpace(workflow.CurrentEntryId) ||
|
|
workflow.CurrentCueIndexZeroBased < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var playlist = _controller.Current.Playlist;
|
|
var currentIndex = workflow.CurrentCueIndexZeroBased;
|
|
return currentIndex < playlist.Count &&
|
|
string.Equals(
|
|
playlist[currentIndex].RowId,
|
|
workflow.CurrentEntryId,
|
|
StringComparison.Ordinal) &&
|
|
playlist.Count(row => string.Equals(
|
|
row.RowId,
|
|
workflow.CurrentEntryId,
|
|
StringComparison.Ordinal)) == 1;
|
|
}
|
|
|
|
private static bool RequiresIdlePlaylistMutation(LegacyUiIntent intent) => intent is
|
|
LegacySetPlaylistEnabledIntent or
|
|
LegacyMoveSelectedPlaylistRowsIntent or
|
|
LegacyReorderPlaylistRowsIntent or
|
|
LegacyDeleteAllPlaylistRowsIntent or
|
|
LegacyLoadSelectedNamedPlaylistIntent or
|
|
LegacyLoadNamedPlaylistByIdIntent;
|
|
|
|
private static bool IsPlaylistMutationIdle(
|
|
PlayoutStatus status,
|
|
LegacyPlayoutWorkflowState workflow) =>
|
|
string.IsNullOrWhiteSpace(status.PreparedSceneName) &&
|
|
string.IsNullOrWhiteSpace(status.OnAirSceneName) &&
|
|
string.IsNullOrWhiteSpace(workflow.PreparedCutCode) &&
|
|
string.IsNullOrWhiteSpace(workflow.OnAirCutCode) &&
|
|
string.IsNullOrWhiteSpace(workflow.CurrentEntryId);
|
|
|
|
private bool CanDeleteSelectedPlaylistTail(
|
|
PlayoutStatus status,
|
|
LegacyPlayoutWorkflowState workflow)
|
|
{
|
|
if (IsPlaylistMutationIdle(status, workflow))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(workflow.CurrentEntryId) ||
|
|
workflow.CurrentCueIndexZeroBased < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var playlist = _controller.Current.Playlist;
|
|
var currentMatches = playlist
|
|
.Select(static (row, index) => (row, index))
|
|
.Where(candidate => string.Equals(
|
|
candidate.row.RowId,
|
|
workflow.CurrentEntryId,
|
|
StringComparison.Ordinal))
|
|
.Select(static candidate => candidate.index)
|
|
.Take(2)
|
|
.ToArray();
|
|
if (currentMatches.Length != 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var currentIndex = currentMatches[0];
|
|
if (currentIndex != workflow.CurrentCueIndexZeroBased)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return playlist
|
|
.Select(static (row, index) => (row, index))
|
|
.Where(static candidate => candidate.row.IsSelected)
|
|
.All(candidate => candidate.index > currentIndex);
|
|
}
|
|
|
|
private bool CanMutatePlaylistEnabledState(
|
|
PlayoutStatus status,
|
|
LegacyPlayoutWorkflowState workflow)
|
|
{
|
|
if (IsPlaylistMutationIdle(status, workflow))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// PREPARED is deliberately not opened: unlike PROGRAM, the original parity
|
|
// evidence does not establish a safe checkbox contract for that phase.
|
|
if (string.IsNullOrWhiteSpace(status.OnAirSceneName) ||
|
|
string.IsNullOrWhiteSpace(workflow.OnAirCutCode) ||
|
|
string.IsNullOrWhiteSpace(workflow.CurrentEntryId) ||
|
|
workflow.CurrentCueIndexZeroBased < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var playlist = _controller.Current.Playlist;
|
|
var currentIndex = workflow.CurrentCueIndexZeroBased;
|
|
return currentIndex < playlist.Count &&
|
|
string.Equals(
|
|
playlist[currentIndex].RowId,
|
|
workflow.CurrentEntryId,
|
|
StringComparison.Ordinal) &&
|
|
playlist.Count(row => string.Equals(
|
|
row.RowId,
|
|
workflow.CurrentEntryId,
|
|
StringComparison.Ordinal)) == 1;
|
|
}
|
|
|
|
private static bool IsOperatorMutationIntent(LegacyUiIntent intent) => intent is
|
|
LegacyCutPointerDownIntent { AllowAppend: true } or
|
|
LegacyDropSelectedCutsIntent or
|
|
LegacySetPlaylistEnabledIntent or
|
|
LegacySetAllPlaylistEnabledIntent or
|
|
LegacyMoveSelectedPlaylistRowsIntent or
|
|
LegacyReorderPlaylistRowsIntent or
|
|
LegacyDeleteSelectedPlaylistRowsIntent or
|
|
LegacyDeleteAllPlaylistRowsIntent or
|
|
LegacyToggleActivePlaylistEnabledIntent or
|
|
LegacyActivateFixedActionIntent or
|
|
LegacyActivateFixedSectionIntent or
|
|
LegacyActivateIndustryActionIntent or
|
|
LegacyActivateIndustrySectionIntent or
|
|
LegacyActivateOverseasActionIntent or
|
|
LegacyAddComparisonPairIntent or
|
|
LegacyImportComparisonPairsIntent or
|
|
LegacyMoveComparisonPairIntent or
|
|
LegacyDeleteSelectedComparisonPairIntent or
|
|
LegacyDeleteAllComparisonPairsIntent or
|
|
LegacyActivateComparisonActionIntent or
|
|
LegacyActivateComparisonSectionIntent or
|
|
LegacyActivateThemeActionIntent or
|
|
LegacyActivateThemeResultIntent or
|
|
LegacyActivateExpertActionIntent or
|
|
LegacyActivateTradingHaltActionIntent or
|
|
LegacyBeginUc4ThemeCatalogIntent or
|
|
LegacyEditUc4SelectedThemeIntent or
|
|
LegacyDeleteUc4SelectedThemeIntent or
|
|
LegacyBeginUc6ExpertCatalogIntent or
|
|
LegacyEditUc6SelectedExpertIntent or
|
|
LegacyDeleteUc6SelectedExpertIntent or
|
|
LegacyBeginCreateThemeCatalogIntent or
|
|
LegacyChangeCreateThemeMarketIntent or
|
|
LegacyBeginCreateExpertCatalogIntent or
|
|
LegacyAddOperatorCatalogStockIntent or
|
|
LegacyActivateOperatorCatalogStockIntent or
|
|
LegacyMoveOperatorCatalogDraftRowIntent or
|
|
LegacyReorderOperatorCatalogDraftRowIntent or
|
|
LegacyRemoveOperatorCatalogDraftRowIntent or
|
|
LegacyRemoveActiveOperatorCatalogDraftRowIntent or
|
|
LegacyClearOperatorCatalogDraftRowsIntent or
|
|
LegacySetOperatorCatalogDraftBuyAmountIntent or
|
|
LegacySaveOperatorCatalogIntent or
|
|
LegacyConfirmNativeDialogIntent or
|
|
LegacyLoadSelectedNamedPlaylistIntent or
|
|
LegacyLoadNamedPlaylistByIdIntent or
|
|
LegacyCreateNamedPlaylistIntent or
|
|
LegacySaveCurrentNamedPlaylistIntent or
|
|
LegacySaveCurrentNamedPlaylistToIntent or
|
|
LegacyDeleteSelectedNamedPlaylistIntent or
|
|
LegacySaveManualFinancialIntent or
|
|
LegacySaveManualFinancialRawIntent or
|
|
LegacyDeleteManualFinancialIntent or
|
|
LegacyDeleteAllManualFinancialIntent or
|
|
LegacyActivateManualFinancialActionIntent or
|
|
LegacyActivateManualFinancialResultIntent or
|
|
LegacySetManualNetSellCellIntent or
|
|
LegacySaveManualNetSellIntent or
|
|
LegacyAddManualNetSellCutIntent or
|
|
LegacyAddManualViResultIntent or
|
|
LegacyMoveManualViItemIntent or
|
|
LegacyDeleteManualViItemIntent or
|
|
LegacyDeleteAllManualViItemsIntent or
|
|
LegacySaveManualViIntent or
|
|
LegacyAddManualViCutIntent or
|
|
LegacyConfirmManualListIntent or
|
|
LegacyImportManualListsIntent;
|
|
|
|
private static bool IsPersistentWriteIntent(LegacyUiIntent intent) => intent is
|
|
LegacyDeleteUc4SelectedThemeIntent or
|
|
LegacyDeleteUc6SelectedExpertIntent or
|
|
LegacySaveOperatorCatalogIntent or
|
|
LegacyConfirmNativeDialogIntent or
|
|
LegacyAddComparisonPairIntent or
|
|
LegacyMoveComparisonPairIntent or
|
|
LegacyDeleteSelectedComparisonPairIntent or
|
|
LegacyDeleteAllComparisonPairsIntent or
|
|
LegacySaveManualFinancialIntent or
|
|
LegacySaveManualFinancialRawIntent or
|
|
LegacyDeleteManualFinancialIntent or
|
|
LegacyDeleteAllManualFinancialIntent or
|
|
LegacySaveManualNetSellIntent or
|
|
LegacySaveManualViIntent or
|
|
LegacyConfirmManualListIntent or
|
|
LegacyImportManualListsIntent or
|
|
LegacyCreateNamedPlaylistIntent or
|
|
LegacySaveCurrentNamedPlaylistIntent or
|
|
LegacySaveCurrentNamedPlaylistToIntent or
|
|
LegacyDeleteSelectedNamedPlaylistIntent or
|
|
LegacyChooseOperatorFolderIntent or
|
|
LegacyResetOperatorFolderIntent or
|
|
LegacySetOperatorNavigationExpandedIntent or
|
|
LegacySetOperatorAppearanceIntent;
|
|
|
|
private static bool IsFixedSectionBatchMutationIntent(LegacyUiIntent intent) => intent is
|
|
LegacySetManualNetSellCellIntent or
|
|
LegacyAddManualViResultIntent or
|
|
LegacyMoveManualViItemIntent or
|
|
LegacyDeleteManualViItemIntent or
|
|
LegacyDeleteAllManualViItemsIntent or
|
|
LegacyConfirmManualListIntent or
|
|
LegacyImportManualListsIntent;
|
|
|
|
private void ObserveOperatorMutationQuarantine(LegacyOperatorSnapshot snapshot)
|
|
{
|
|
if (snapshot.ManualFinancial?.WritesQuarantined == true ||
|
|
snapshot.NamedPlaylist?.IsWriteQuarantined == true ||
|
|
snapshot.ManualLists?.WritesQuarantined == true ||
|
|
snapshot.OperatorCatalog?.WritesQuarantined == true)
|
|
{
|
|
Interlocked.Exchange(ref _operatorMutationQuarantined, 1);
|
|
}
|
|
}
|
|
|
|
private bool IsOperatorMutationQuarantined() =>
|
|
Volatile.Read(ref _operatorMutationQuarantined) != 0;
|
|
|
|
private LegacyWorkflowNextKind ResolveOperatorNextKind(
|
|
LegacyOperatorPlayoutPhase phase,
|
|
LegacyPlayoutWorkflowState? workflow)
|
|
{
|
|
var retainedKind = workflow?.NextKind ?? LegacyWorkflowNextKind.None;
|
|
if (phase != LegacyOperatorPlayoutPhase.Program || workflow is null)
|
|
{
|
|
return retainedKind;
|
|
}
|
|
|
|
// The workflow snapshot is intentionally frozen until NEXT. MainForm's
|
|
// PROGRAM Space/"all" gestures, however, immediately changed which future
|
|
// row NEXT would choose. Derive the visible/available NEXT state from the
|
|
// live operator flags without mutating the scene retained by the engine.
|
|
if (!workflow.IsLastPage)
|
|
{
|
|
return LegacyWorkflowNextKind.PageNext;
|
|
}
|
|
|
|
var currentIndex = workflow.CurrentCueIndexZeroBased;
|
|
var playlist = _controller.Current.Playlist;
|
|
if (currentIndex < 0 || currentIndex >= playlist.Count ||
|
|
string.IsNullOrWhiteSpace(workflow.CurrentEntryId) ||
|
|
!string.Equals(
|
|
playlist[currentIndex].RowId,
|
|
workflow.CurrentEntryId,
|
|
StringComparison.Ordinal))
|
|
{
|
|
return LegacyWorkflowNextKind.None;
|
|
}
|
|
|
|
return playlist
|
|
.Skip(currentIndex + 1)
|
|
.Any(static row => row.IsEnabled)
|
|
? LegacyWorkflowNextKind.PlaylistNext
|
|
: LegacyWorkflowNextKind.EndOfPlaylist;
|
|
}
|
|
|
|
private LegacyOperatorPlayoutSnapshot CreatePlayoutSnapshot()
|
|
{
|
|
var status = _playoutEngine?.Status;
|
|
var workflow = _playoutWorkflow?.State;
|
|
var refresh = _refreshEpoch.ReadState();
|
|
var composition = _stagedCompositionOptions?.Current ??
|
|
_compositionOptions?.Current ??
|
|
LegacySceneCueCompositionOptions.Default;
|
|
var quarantined = Volatile.Read(ref _playoutQuarantined) != 0 ||
|
|
status?.State == PlayoutConnectionState.OutcomeUnknown;
|
|
var phase = !string.IsNullOrWhiteSpace(status?.OnAirSceneName)
|
|
? LegacyOperatorPlayoutPhase.Program
|
|
: !string.IsNullOrWhiteSpace(status?.PreparedSceneName)
|
|
? LegacyOperatorPlayoutPhase.Prepared
|
|
: LegacyOperatorPlayoutPhase.Idle;
|
|
var nextKind = ResolveOperatorNextKind(phase, workflow);
|
|
var backgroundEnabled =
|
|
composition.BackgroundKind != LegacySceneBackgroundKind.None;
|
|
var snapshot = new LegacyOperatorPlayoutSnapshot(
|
|
status?.Mode ?? PlayoutMode.Disabled,
|
|
quarantined
|
|
? PlayoutConnectionState.OutcomeUnknown
|
|
: status?.State ?? PlayoutConnectionState.Disabled,
|
|
phase,
|
|
status?.IsProcessRunning ?? false,
|
|
status?.IsConnected ?? false,
|
|
(status?.IsCommandAvailable ?? false) && !quarantined,
|
|
(status?.LiveTakeInAllowed ?? false) && !quarantined,
|
|
status?.IsPlayCompletionPending ?? false,
|
|
quarantined,
|
|
status?.PreparedSceneName,
|
|
status?.OnAirSceneName,
|
|
workflow?.CurrentCueIndexZeroBased ?? -1,
|
|
workflow?.CurrentEntryId,
|
|
workflow?.BuilderKey,
|
|
workflow?.PageIndexZeroBased ?? 0,
|
|
workflow?.PageCount ?? 0,
|
|
workflow?.PageSize ?? 0,
|
|
workflow?.ItemCount ?? 0,
|
|
workflow?.CurrentPageItemCount ?? 0,
|
|
workflow?.IsLastPage ?? true,
|
|
nextKind,
|
|
Volatile.Read(ref _playoutBusy) != 0,
|
|
refresh.IsActive,
|
|
refresh.CompletedRefreshCount,
|
|
refresh.MaximumRefreshCount,
|
|
refresh.IsLimitReached,
|
|
composition.FadeDuration,
|
|
backgroundEnabled,
|
|
backgroundEnabled
|
|
? Path.GetFileName(composition.BackgroundAssetPath) ?? string.Empty
|
|
: string.Empty,
|
|
CanStageBackground(),
|
|
quarantined
|
|
? "결과 불명확 상태입니다. 명령을 반복하지 마세요."
|
|
: refresh.Message.Length > 0
|
|
? refresh.Message
|
|
: _playoutInitializationWarning ?? status?.Message ??
|
|
_playoutInitializationError ??
|
|
"송출 어댑터를 사용할 수 없습니다.");
|
|
return snapshot with
|
|
{
|
|
IsTakeOutCompletionPending = status?.IsTakeOutCompletionPending ?? false,
|
|
RefreshNextAtUtc = refresh.NextAtUtc,
|
|
RefreshLastSuccessAtUtc = refresh.LastSuccessAtUtc,
|
|
RefreshFaultCode = refresh.FaultCode
|
|
};
|
|
}
|
|
|
|
private void StartRefreshLoop(LegacyPlayoutWorkflow workflow)
|
|
{
|
|
ResetRefreshState();
|
|
var cutCode = workflow.State.OnAirCutCode;
|
|
if (!LegacySceneRefreshPolicy.TryGetInterval(cutCode, out var firstInterval) ||
|
|
firstInterval <= TimeSpan.Zero ||
|
|
Volatile.Read(ref _playoutShutdownStarted) != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var scheduler = new LegacyRefreshScheduler(
|
|
firstInterval,
|
|
LegacySceneRefreshPolicy.RecurringInterval,
|
|
_playoutOptions?.MaximumAutomaticRefreshesPerTakeIn);
|
|
if (scheduler.HasReachedMaximum)
|
|
{
|
|
_refreshTask = Task.CompletedTask;
|
|
_refreshEpoch.Stop(_ => LegacyRefreshRuntimeStatus.Empty with
|
|
{
|
|
MaximumRefreshCount = scheduler.MaximumRefreshCount,
|
|
IsLimitReached = true,
|
|
Message = $"자동 갱신 상한 {scheduler.MaximumRefreshCount}회가 설정되어 자동 갱신을 시작하지 않았습니다."
|
|
});
|
|
QueueOperatorState();
|
|
return;
|
|
}
|
|
|
|
var cancellation = CancellationTokenSource.CreateLinkedTokenSource(
|
|
_lifetimeCancellation.Token);
|
|
_refreshEpoch.Replace(
|
|
cancellation,
|
|
_ => new LegacyRefreshRuntimeStatus(
|
|
true,
|
|
null,
|
|
null,
|
|
false,
|
|
null,
|
|
string.Empty,
|
|
scheduler.CompletedRefreshCount,
|
|
scheduler.MaximumRefreshCount,
|
|
false));
|
|
_refreshTask = RunRefreshLoopAsync(workflow, scheduler, cancellation);
|
|
}
|
|
|
|
private void StopRefreshLoop() =>
|
|
_refreshEpoch.Stop(status => status with
|
|
{
|
|
IsActive = false,
|
|
NextAtUtc = null
|
|
});
|
|
|
|
private void ResetRefreshState() =>
|
|
_refreshEpoch.Stop(_ => LegacyRefreshRuntimeStatus.Empty with
|
|
{
|
|
MaximumRefreshCount = _playoutOptions?.MaximumAutomaticRefreshesPerTakeIn
|
|
});
|
|
|
|
private async Task RunRefreshLoopAsync(
|
|
LegacyPlayoutWorkflow workflow,
|
|
LegacyRefreshScheduler scheduler,
|
|
CancellationTokenSource cancellation)
|
|
{
|
|
var token = cancellation.Token;
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
var engine = _playoutEngine;
|
|
if (engine is null ||
|
|
!ReferenceEquals(_playoutWorkflow, workflow) ||
|
|
!_refreshEpoch.IsCurrent(cancellation) ||
|
|
Volatile.Read(ref _playoutShutdownStarted) != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (engine.Status.State == PlayoutConnectionState.OutcomeUnknown)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"PLAYOUT_OUTCOME_UNKNOWN",
|
|
"송출 상태가 불명확하여 자동 갱신을 시작하지 않았습니다.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return;
|
|
}
|
|
|
|
if (scheduler.HasReachedMaximum)
|
|
{
|
|
if (!await scheduler.DrainMaximumCallbackAsync(
|
|
callbackToken => WaitForPlayCompletionAsync(
|
|
engine,
|
|
callbackToken),
|
|
token).ConfigureAwait(false))
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"PLAY_CALLBACK_TIMEOUT",
|
|
"자동 갱신 상한에 도달했지만 마지막 재생 완료 이벤트를 확인하지 못했습니다. 결과가 불명확하므로 PGM을 확인하세요.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return;
|
|
}
|
|
|
|
if (engine.Status.State == PlayoutConnectionState.OutcomeUnknown)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"PLAY_CALLBACK_OUTCOME_UNKNOWN",
|
|
"마지막 재생 완료 상태가 불명확합니다. PGM과 Network Monitoring을 확인하세요.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return;
|
|
}
|
|
|
|
_refreshEpoch.TryUpdate(
|
|
cancellation,
|
|
status => status with
|
|
{
|
|
IsActive = false,
|
|
NextAtUtc = null,
|
|
CompletedRefreshCount = scheduler.CompletedRefreshCount,
|
|
MaximumRefreshCount = scheduler.MaximumRefreshCount,
|
|
IsLimitReached = true,
|
|
Message = $"자동 갱신 상한 {scheduler.MaximumRefreshCount}회에 도달했습니다."
|
|
});
|
|
QueueOperatorState();
|
|
return;
|
|
}
|
|
|
|
if (!await scheduler.WaitForNextRefreshAsync(
|
|
callbackToken => WaitForPlayCompletionAsync(
|
|
engine,
|
|
callbackToken),
|
|
scheduledDelay =>
|
|
{
|
|
if (_refreshEpoch.TryUpdate(
|
|
cancellation,
|
|
status => status.IsActive
|
|
? status with
|
|
{
|
|
NextAtUtc = DateTimeOffset.UtcNow.Add(scheduledDelay)
|
|
}
|
|
: status))
|
|
{
|
|
QueueOperatorState();
|
|
}
|
|
},
|
|
token).ConfigureAwait(false))
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"PLAY_CALLBACK_TIMEOUT",
|
|
"재생 완료 이벤트를 확인하지 못해 자동 갱신을 중단했습니다. 결과가 불명확하므로 PGM을 확인하세요.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return;
|
|
}
|
|
|
|
if (!ReferenceEquals(_playoutWorkflow, workflow) ||
|
|
!_refreshEpoch.IsCurrent(cancellation) ||
|
|
Volatile.Read(ref _playoutShutdownStarted) != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (engine.Status.State == PlayoutConnectionState.OutcomeUnknown)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"PLAY_CALLBACK_OUTCOME_UNKNOWN",
|
|
"재생 완료 상태가 불명확하여 자동 갱신을 시작하지 않았습니다.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return;
|
|
}
|
|
|
|
var intentGateEntered = false;
|
|
var databaseGateEntered = false;
|
|
var playoutGateEntered = false;
|
|
try
|
|
{
|
|
// Match MainForm's single UI thread: Web DB work and the timer
|
|
// refresh are serialized in the same order as ProcessIntentAsync.
|
|
await _intentGate.WaitAsync(token).ConfigureAwait(false);
|
|
intentGateEntered = true;
|
|
_intentBusy = true;
|
|
QueueOperatorState();
|
|
|
|
await AcquirePriorityDatabaseActivityAsync(token).ConfigureAwait(false);
|
|
databaseGateEntered = true;
|
|
|
|
await _playoutCommandGate.WaitAsync(token).ConfigureAwait(false);
|
|
playoutGateEntered = true;
|
|
Interlocked.Exchange(ref _playoutBusy, 1);
|
|
QueueOperatorState();
|
|
|
|
if (!_refreshEpoch.IsCurrent(cancellation) ||
|
|
Volatile.Read(ref _playoutShutdownStarted) != 0 ||
|
|
engine.Status.State == PlayoutConnectionState.OutcomeUnknown)
|
|
{
|
|
if (engine.Status.State == PlayoutConnectionState.OutcomeUnknown)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"REFRESH_OUTCOME_UNKNOWN",
|
|
"송출 상태가 불명확하여 자동 갱신을 시작하지 않았습니다.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
}
|
|
return;
|
|
}
|
|
|
|
var result = await scheduler.ExecuteRefreshAndTrackSuccessAsync(
|
|
workflow.RefreshOnAirAsync,
|
|
static refreshResult => refreshResult.IsSuccess,
|
|
token).ConfigureAwait(false);
|
|
if (!result.IsSuccess)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
RefreshFaultCode(result.Code),
|
|
"자동 장면 갱신을 중단했습니다. TAKE OUT 전 실제 데이터와 PGM을 확인하세요.");
|
|
if (result.Code is PlayoutResultCode.OutcomeUnknown or
|
|
PlayoutResultCode.TimedOut)
|
|
{
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (!_refreshEpoch.TryUpdate(
|
|
cancellation,
|
|
_ => new LegacyRefreshRuntimeStatus(
|
|
true,
|
|
null,
|
|
DateTimeOffset.UtcNow,
|
|
false,
|
|
null,
|
|
string.Empty,
|
|
scheduler.CompletedRefreshCount,
|
|
scheduler.MaximumRefreshCount,
|
|
false)))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
catch (OperationCanceledException) when (token.IsCancellationRequested)
|
|
{
|
|
return;
|
|
}
|
|
catch (DatabaseInfrastructureException)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"DATABASE_UNAVAILABLE",
|
|
"자동 장면 갱신 중 데이터베이스 조회가 실패했습니다. TAKE OUT 후 확인하세요.");
|
|
return;
|
|
}
|
|
catch (LegacySceneDataException)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"SCENE_DATA_INVALID",
|
|
"자동 장면 갱신 데이터가 유효하지 않습니다. TAKE OUT 후 확인하세요.");
|
|
return;
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"SCENE_ARGUMENT_INVALID",
|
|
"자동 장면 갱신 요청 데이터가 유효하지 않습니다. TAKE OUT 후 확인하세요.");
|
|
return;
|
|
}
|
|
catch
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"REFRESH_OUTCOME_UNKNOWN",
|
|
"자동 갱신 결과가 불명확합니다. 명령을 반복하지 마세요.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
return;
|
|
}
|
|
finally
|
|
{
|
|
if (playoutGateEntered)
|
|
{
|
|
Interlocked.Exchange(ref _playoutBusy, 0);
|
|
_playoutCommandGate.Release();
|
|
}
|
|
|
|
if (databaseGateEntered)
|
|
{
|
|
_databaseActivityGate.Release();
|
|
}
|
|
|
|
if (intentGateEntered)
|
|
{
|
|
_intentBusy = false;
|
|
_intentGate.Release();
|
|
}
|
|
|
|
QueueOperatorState();
|
|
}
|
|
}
|
|
}
|
|
catch (OperationCanceledException) when (token.IsCancellationRequested)
|
|
{
|
|
}
|
|
catch
|
|
{
|
|
TrySetRefreshFault(
|
|
cancellation,
|
|
"REFRESH_SCHEDULER_UNKNOWN",
|
|
"자동 갱신 예약 상태를 확인할 수 없습니다. 명령을 반복하지 마세요.");
|
|
await QuarantinePlayoutAsync().ConfigureAwait(false);
|
|
}
|
|
finally
|
|
{
|
|
var completedCurrentEpoch = _refreshEpoch.TryComplete(
|
|
cancellation,
|
|
status => status with
|
|
{
|
|
IsActive = false,
|
|
NextAtUtc = null
|
|
});
|
|
cancellation.Dispose();
|
|
if (completedCurrentEpoch)
|
|
{
|
|
QueueOperatorState();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool TrySetRefreshFault(
|
|
CancellationTokenSource cancellation,
|
|
string code,
|
|
string message) =>
|
|
_refreshEpoch.TryUpdate(
|
|
cancellation,
|
|
status => status with
|
|
{
|
|
IsActive = false,
|
|
NextAtUtc = null,
|
|
IsFaulted = true,
|
|
FaultCode = code,
|
|
Message = message
|
|
});
|
|
|
|
private static string RefreshFaultCode(PlayoutResultCode code) => code switch
|
|
{
|
|
PlayoutResultCode.OutcomeUnknown => "OUTCOME_UNKNOWN",
|
|
PlayoutResultCode.TimedOut => "TIMED_OUT",
|
|
PlayoutResultCode.Rejected => "REJECTED",
|
|
PlayoutResultCode.Cancelled => "CANCELLED",
|
|
PlayoutResultCode.Unavailable => "UNAVAILABLE",
|
|
PlayoutResultCode.Failed => "FAILED",
|
|
_ => "REFRESH_FAILED"
|
|
};
|
|
|
|
private static async Task<bool> WaitForPlayCompletionAsync(
|
|
IPlayoutEngine engine,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!engine.Status.IsPlayCompletionPending)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var timeout = Math.Clamp(
|
|
engine.Status.OperationTimeoutMilliseconds,
|
|
100,
|
|
300_000);
|
|
using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
|
|
linked.CancelAfter(timeout);
|
|
while (engine.Status.IsPlayCompletionPending)
|
|
{
|
|
var completion = new TaskCompletionSource(
|
|
TaskCreationOptions.RunContinuationsAsynchronously);
|
|
void OnStatus(object? sender, PlayoutStatusChangedEventArgs args)
|
|
{
|
|
if (!args.Current.IsPlayCompletionPending)
|
|
{
|
|
completion.TrySetResult();
|
|
}
|
|
}
|
|
|
|
engine.StatusChanged += OnStatus;
|
|
try
|
|
{
|
|
if (!engine.Status.IsPlayCompletionPending)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
await completion.Task.WaitAsync(linked.Token).ConfigureAwait(false);
|
|
}
|
|
catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
engine.StatusChanged -= OnStatus;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private async ValueTask QuarantinePlayoutAsync()
|
|
{
|
|
if (Interlocked.Exchange(ref _playoutQuarantined, 1) != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
StopRefreshLoop();
|
|
if (_playoutEngine is not null)
|
|
{
|
|
try
|
|
{
|
|
await _playoutEngine.QuarantineAsync().ConfigureAwait(false);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
private void QueueOperatorState()
|
|
{
|
|
if (_closing || !_webViewReady)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DispatcherQueue.TryEnqueue(() =>
|
|
{
|
|
if (!_closing)
|
|
{
|
|
PostState(_controller.Current);
|
|
}
|
|
});
|
|
}
|
|
|
|
private async Task ShutdownPlayoutRuntimeAsync()
|
|
{
|
|
if (Interlocked.Exchange(ref _playoutShutdownStarted, 1) != 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
StopRefreshLoop();
|
|
var refresh = _refreshTask;
|
|
if (refresh is not null)
|
|
{
|
|
try
|
|
{
|
|
await refresh.WaitAsync(TimeSpan.FromSeconds(2));
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
var engine = _playoutEngine;
|
|
_playoutEngine = null;
|
|
_playoutWorkflow = null;
|
|
if (engine is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
engine.StatusChanged -= OnPlayoutStatusChanged;
|
|
try
|
|
{
|
|
if (Volatile.Read(ref _playoutQuarantined) == 0 &&
|
|
engine.Status.State != PlayoutConnectionState.OutcomeUnknown &&
|
|
string.IsNullOrWhiteSpace(engine.Status.OnAirSceneName) &&
|
|
!engine.Status.IsPlayCompletionPending &&
|
|
!engine.Status.IsTakeOutCompletionPending)
|
|
{
|
|
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
|
await engine.DisconnectAsync(timeout.Token).ConfigureAwait(false);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
await engine.DisposeAsync().ConfigureAwait(false);
|
|
}
|
|
|
|
private void ShutdownPlayoutRuntime()
|
|
{
|
|
try
|
|
{
|
|
ShutdownPlayoutRuntimeAsync()
|
|
.Wait(TimeSpan.FromSeconds(8));
|
|
}
|
|
catch
|
|
{
|
|
// Window shutdown is bounded and best-effort. The engine itself keeps an
|
|
// outcome-unknown session quarantined and will not send a duplicate BYE.
|
|
}
|
|
}
|
|
|
|
private sealed record LegacyRefreshRuntimeStatus(
|
|
bool IsActive,
|
|
DateTimeOffset? NextAtUtc,
|
|
DateTimeOffset? LastSuccessAtUtc,
|
|
bool IsFaulted,
|
|
string? FaultCode,
|
|
string Message,
|
|
int CompletedRefreshCount,
|
|
int? MaximumRefreshCount,
|
|
bool IsLimitReached)
|
|
{
|
|
internal static LegacyRefreshRuntimeStatus Empty { get; } = new(
|
|
false,
|
|
null,
|
|
null,
|
|
false,
|
|
null,
|
|
string.Empty,
|
|
0,
|
|
null,
|
|
false);
|
|
}
|
|
}
|