SplashScreen.cs

using System.Drawing;
using Gondwana.Drawing.Direct;
using Gondwana.Logging;
using Gondwana.Rendering;
using Gondwana.Rendering.Views;
using Gondwana.Timers;
using Microsoft.Extensions.Logging;
using SkiaSharp;
using Timer = Gondwana.Timers.Timer;
 
namespace Gondwana.Widgets.Overlays;

public sealed class SplashScreen : WidgetBase
{
    private static readonly ILogger<SplashScreen> Logger =
        EngineLogger.GetLogger<SplashScreen>();

    public enum State
    {
        Hidden,

        FadingIn,

        Holding,

        FadingOut
    }

    public static readonly string SplashImageNickname = "__gondwana_splash__";
 
    private readonly View _view;
    private Timer? _holdTimer;
    private TaskCompletionSource? _holdDurationCompletionSource;
    private bool _disposed;
 
    #region properties

    public DirectImage Image { get; private set; }

    public State CurrentState { get; private set; }

    public float FadeInSec { get; private set; }

    public float HoldSec { get; private set; }

    public float FadeOutSec { get; private set; }
 
    #endregion properties
 
    #region factory / constructor
 
    private SplashScreen(DirectImage image,
                         float fadeInSec,
                         float holdSec,
                         float fadeOutSec,
                         Action? onHoldingSync,
                         Func<Task>? onHoldingAsync,
                         Action? onSplashCompleted)
        : base(image.RenderSurfaceHost,
               DirectDrawingMode.View,
               PointF.Empty,
               SplashImageNickname + Guid.NewGuid())
    {
        Image = image;
        _view = image.View
            ?? throw new InvalidOperationException("Splash image must be attached to a view.");
        _view.Viewport.TargetRectChanged += OnViewportTargetRectChanged;
        CurrentState = State.Hidden;
 
        FadeInSec = fadeInSec;
        HoldSec = holdSec;
        FadeOutSec = fadeOutSec;
 
        Add(Image);
 
        StartFadeIn(
            onHoldingSync,
            onHoldingAsync,
            onSplashCompleted);
    }

    public static SplashScreen? TryCreate(Stream imageStream,
                                          RenderSurfaceHostBase host,
                                          View view,
                                          float fadeInSec = 0.45f,
                                          float holdSec = 3f,
                                          float fadeOutSec = 0.45f,
                                          Action? onHoldingSync = null,
                                          Func<Task>? onHoldingAsync = null,
                                          Action? onSplashCompleted = null)
    {
        if (host.ViewManager.Views.Count == 0)
            return null;
 
        using var bitmap = SKBitmap.Decode(imageStream);
 
        var sourceImage = bitmap is null
            ? null
            : SKImage.FromBitmap(bitmap);
 
        if (sourceImage is null)
            return null;
 
        var viewport = view.Viewport.TargetRectPx;
 
        var screenBounds = viewport;
 
        var image = new DirectImage(
                sourceImage,
                host,
                view,
                screenBounds,
                SplashImageNickname)
            .SetScaleMode(DirectImage.ScaleMode.Fit);
 
        // DirectImage does not own the SKImage lifetime.
        image.Disposing += (_, _) => sourceImage.Dispose();
 
        image.ZOrder = int.MaxValue;
        image.Opacity = 0f;
 
        return new SplashScreen(
            image,
            fadeInSec,
            holdSec,
            fadeOutSec,
            onHoldingSync,
            onHoldingAsync,
            onSplashCompleted);
    }
 
    #endregion factory / constructor

    public override void Dispose()
    {
        if (_disposed)
            return;
 
        _disposed = true;
 
        _view.Viewport.TargetRectChanged -= OnViewportTargetRectChanged;
 
        _holdTimer?.Dispose();
        _holdTimer = null;
 
        _holdDurationCompletionSource?.TrySetCanceled();
        _holdDurationCompletionSource = null;
 
        base.Dispose();
    }
 
    private void OnViewportTargetRectChanged(ViewportResizedEventArgs args)
    {
        if (_disposed)
            return;
 
        Image.ScreenBounds = args.NewRect;
    }
 
    #region splash control
 
    private void StartFadeIn(Action? onHoldingSync, Func<Task>? onHoldingAsync, Action? onSplashCompleted)
    {
        Logger.LogDebug("Starting splash screen fade-in");
 
        CurrentState = State.FadingIn;
 
        EventHandler<DirectDrawingBase>? fadeInHandler = null;
 
        fadeInHandler = (_, _) =>
        {
            Image.FadeToCompleted -= fadeInHandler;
 
            if (_disposed)
                return;
 
            CurrentState = State.Holding;
 
            _ = RunHoldPhaseAsync(
                onHoldingSync,
                onHoldingAsync,
                onSplashCompleted);
        };
 
        Image.FadeToCompleted += fadeInHandler;
 
        Image.FadeIn(FadeInSec);
    }
 
    private async Task RunHoldPhaseAsync(
        Action? onHoldingSync,
        Func<Task>? onHoldingAsync,
        Action? onSplashCompleted)
    {
        Logger.LogDebug("Starting splash screen hold phase");
 
        try
        {
            var holdDurationTask = WaitForHoldDurationAsync();
 
            var delegateTask = ExecuteHoldDelegatesAsync(onHoldingSync, onHoldingAsync);
 
            await Task.WhenAll(
                holdDurationTask,
                delegateTask);
        }
        catch (OperationCanceledException)
            when (_disposed)
        {
            return;
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "Unexpected error during SplashScreen hold phase");
        }
        finally
        {
            _holdTimer?.Dispose();
            _holdTimer = null;
 
            _holdDurationCompletionSource = null;
        }
 
        if (_disposed)
            return;
 
        Engine.Instance.EngineDispatcher.Post(() =>
        {
            if (_disposed)
                return;
 
            if (CurrentState != State.Holding)
                return;
 
            StartFadeOut(onSplashCompleted);
        });
    }
 
    private Task WaitForHoldDurationAsync()
    {
        var completionSource = new TaskCompletionSource(
            TaskCreationOptions.RunContinuationsAsynchronously);
 
        _holdDurationCompletionSource =
            completionSource;
 
        var timer = Timer.Add(
            TimerType.PostCycle,
            TimerCycles.Once,
            HoldSec);
 
        _holdTimer = timer;
 
        void OnHoldTimerElapsed()
        {
            timer.Tick -= OnHoldTimerElapsed;
 
            completionSource.TrySetResult();
        }
 
        timer.Tick += OnHoldTimerElapsed;
 
        return completionSource.Task;
    }
 
    private static async Task ExecuteHoldDelegatesAsync(
        Action? onHoldingSync,
        Func<Task>? onHoldingAsync)
    {
        if (onHoldingSync is null &&
            onHoldingAsync is null)
        {
            return;
        }
 
        var dispatcher =
            Engine.Instance.EngineDispatcher;
 
        try
        {
            await dispatcher.PostAsync(async () =>
            {
                Task asyncTask =
                    Task.CompletedTask;
 
                Task syncTask =
                    Task.CompletedTask;
 
                if (onHoldingAsync is not null)
                {
                    Logger.LogDebug("Calling onHoldingAsync in SplashScreen");
 
                    try
                    {
                        asyncTask = onHoldingAsync() ?? Task.CompletedTask;
                    }
                    catch (Exception ex)
                    {
                        asyncTask = Task.FromException(ex);
                    }
                }
 
                if (onHoldingSync is not null)
                {
                    Logger.LogDebug("Calling onHoldingSync in SplashScreen");
 
                    try
                    {
                        onHoldingSync();
                    }
                    catch (Exception ex)
                    {
                        syncTask = Task.FromException(ex);
                    }
                }
 
                await Task.WhenAll(asyncTask, syncTask);
            });
        }
        catch (Exception ex)
        {
            Logger.LogError(ex, "Error executing SplashScreen hold delegates");
        }
    }
 
    private void StartFadeOut(Action? onSplashCompleted)
    {
        Logger.LogDebug("Starting splash screen fade-out");
 
        CurrentState = State.FadingOut;
 
        EventHandler<DirectDrawingBase>? fadeOutHandler = null;
 
        fadeOutHandler = (_, _) =>
        {
            Image.FadeToCompleted -= fadeOutHandler;
            CurrentState = State.Hidden;
            Dispose();
            onSplashCompleted?.Invoke();
        };
 
        Image.FadeToCompleted += fadeOutHandler;
        Image.FadeOut(FadeOutSec);
    }
 
    #endregion splash control
}