24746555599

Committed 21 Apr 2026 09:07PM UTC coverage: 30.388% (-0.2%) from 30.6%

Build # 24746555599

Build Type

push

coveralls.net

Committed by

DemoBytom

Commit Message

WIP new WindowsMessagePump

Coverage Stats

1283 of 4222 relevant lines covered (30.39%)

0.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Demo.Engine.Core/Services/EngineService.cs

// Copyright © Michał Dembski and contributors.
// Distributed under MIT license. See LICENSE file in the root for more information.

using System.Reflection;
using Demo.Engine.Core.Interfaces;
using Demo.Engine.Core.Requests;
using Mediator;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace Demo.Engine.Core.Services;

internal sealed class EngineService(
    ILogger<EngineService> logger,
    IHostApplicationLifetime hostApplicationLifetime,
    IServiceScopeFactory scopeFactory,
    IMediator mediator)
    : IHostedService,
      IDisposable
{
    private readonly ILogger<EngineService> _logger = logger;
    private readonly IHostApplicationLifetime _hostApplicationLifetime = hostApplicationLifetime;
    private readonly IServiceScopeFactory _scopeFactory = scopeFactory;
    private readonly IMediator _mediator = mediator;
    private readonly string _serviceName = "Engine";
    private Task? _executingTask;
    private bool _stopRequested;
    private bool _disposedValue;

    private readonly string _version = Assembly
        .GetEntryAssembly()
        ?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
        ?.InformationalVersion ?? "0.0.0";

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogServiceIsStarting(_serviceName, _version);
        _executingTask = DoWorkAsync();

        return _executingTask.IsCompleted
            ? _executingTask
            : Task.CompletedTask;
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogServiceStopping(_serviceName);

        _stopRequested = true;
        if (_executingTask is null)
        {
            return;
        }

        _ = await Task.WhenAny(
            _executingTask,
            Task.Delay(Timeout.Infinite, cancellationToken));
    }

    private async Task DoWorkAsync()
    {
        await using var scope = _scopeFactory.CreateAsyncScope();
        var serviceProvider = scope.ServiceProvider;
        var mainLoopLifetime = serviceProvider.GetService<IMainLoopLifetime>();

        try
        {
            //var osMessageHandler = serviceProvider.GetRequiredService<IOSMessageHandler>();
            //var renderingEngine = serviceProvider.GetRequiredService<IRenderingEngine>();

            _ = await _mediator.Send(new CompileShaders(), _hostApplicationLifetime.ApplicationStopping);
            _ = await _mediator.Send(new LoadShadersRequest(), _hostApplicationLifetime.ApplicationStopping);

            var mainLoopService = serviceProvider.GetRequiredService<IMainLoopService>();
            var executeAsync = mainLoopService.ExecutingTask;

            //var staThreadService = serviceProvider.GetRequiredService<IStaThreadService>();
            //var runStaThread = staThreadService.ExecutingTask;

            await Task.WhenAll(
                [
                    executeAsync/*,
                    runStaThread*/
                ]);
        }
        catch (OperationCanceledException)
        {
            mainLoopLifetime?.Cancel();
        }
        catch (Exception ex)
        {
            _logger.LogServiceFailedWithError(ex, _serviceName);
        }
        finally
        {
            if (!_stopRequested)
            {
                //await Task.Delay(10_000);
                await scope.DisposeAsync();
                _hostApplicationLifetime.StopApplication();
            }
        }
    }

    private void Dispose(bool disposing)
    {
        if (!_disposedValue)
        {
            if (disposing)
            {
                _hostApplicationLifetime.StopApplication();
            }

            _disposedValue = true;
        }
    }

    public void Dispose()
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
}

1	// Copyright © Michał Dembski and contributors.
2	// Distributed under MIT license. See LICENSE file in the root for more information.
3
4	using System.Reflection;
5	using Demo.Engine.Core.Interfaces;
6	using Demo.Engine.Core.Requests;
7	using Mediator;
8	using Microsoft.Extensions.DependencyInjection;
9	using Microsoft.Extensions.Hosting;
10	using Microsoft.Extensions.Logging;
11
12	namespace Demo.Engine.Core.Services;
13
14	internal sealed class EngineService(	×
15	ILogger<EngineService> logger,	×
16	IHostApplicationLifetime hostApplicationLifetime,	×
17	IServiceScopeFactory scopeFactory,	×
18	IMediator mediator)	×
19	: IHostedService,
20	IDisposable
21	{
22	private readonly ILogger<EngineService> _logger = logger;	×
23	private readonly IHostApplicationLifetime _hostApplicationLifetime = hostApplicationLifetime;	×
24	private readonly IServiceScopeFactory _scopeFactory = scopeFactory;	×
25	private readonly IMediator _mediator = mediator;	×
26	private readonly string _serviceName = "Engine";	×
27	private Task? _executingTask;
28	private bool _stopRequested;
29	private bool _disposedValue;
30
31	private readonly string _version = Assembly	×
32	.GetEntryAssembly()	×
33	?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()	×
34	?.InformationalVersion ?? "0.0.0";	×
35
36	public Task StartAsync(CancellationToken cancellationToken)
37	{
38	_logger.LogServiceIsStarting(_serviceName, _version);	×
39	_executingTask = DoWorkAsync();	×
40
41	return _executingTask.IsCompleted	×
42	? _executingTask	×
43	: Task.CompletedTask;	×
44	}
45
46	public async Task StopAsync(CancellationToken cancellationToken)
47	{
48	_logger.LogServiceStopping(_serviceName);	×
49
50	_stopRequested = true;	×
51	if (_executingTask is null)	×
52	{
53	return;	×
54	}
55
56	_ = await Task.WhenAny(	×
57	_executingTask,	×
58	Task.Delay(Timeout.Infinite, cancellationToken));	×
59	}	×
60
61	private async Task DoWorkAsync()
62	{
63	await using var scope = _scopeFactory.CreateAsyncScope();	×
64	var serviceProvider = scope.ServiceProvider;	×
65	var mainLoopLifetime = serviceProvider.GetService<IMainLoopLifetime>();	×
66
67	try
68	{
69	//var osMessageHandler = serviceProvider.GetRequiredService<IOSMessageHandler>();
70	//var renderingEngine = serviceProvider.GetRequiredService<IRenderingEngine>();
71
72	_ = await _mediator.Send(new CompileShaders(), _hostApplicationLifetime.ApplicationStopping);	×
73	_ = await _mediator.Send(new LoadShadersRequest(), _hostApplicationLifetime.ApplicationStopping);	×
74
75	var mainLoopService = serviceProvider.GetRequiredService<IMainLoopService>();	×
76	var executeAsync = mainLoopService.ExecutingTask;	×
77
78	//var staThreadService = serviceProvider.GetRequiredService<IStaThreadService>();
79	//var runStaThread = staThreadService.ExecutingTask;
80
81	await Task.WhenAll(	×
82	[	×
83	executeAsync/*,	×
84	runStaThread*/	×
85	]);	×
86	}	×
87	catch (OperationCanceledException)	×
88	{
89	mainLoopLifetime?.Cancel();	×
90	}	×
91	catch (Exception ex)	×
92	{
93	_logger.LogServiceFailedWithError(ex, _serviceName);	×
94	}	×
95	finally
96	{
97	if (!_stopRequested)	×
98	{
99	//await Task.Delay(10_000);
100	await scope.DisposeAsync();	×
101	_hostApplicationLifetime.StopApplication();	×
102	}
103	}
104	}	×
105
106	private void Dispose(bool disposing)
107	{
108	if (!_disposedValue)	×
109	{
110	if (disposing)	×
111	{
112	_hostApplicationLifetime.StopApplication();	×
113	}
114
115	_disposedValue = true;	×
116	}
117	}	×
118
119	public void Dispose()
120	{
121	// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
122	Dispose(disposing: true);	×
123	GC.SuppressFinalize(this);	×
124	}	×
125	}

DemoBytom / DemoEngine / 24746555599

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous