diff --git a/Avalonia.Desktop.slnf b/Avalonia.Desktop.slnf index 477aaec6a8..a87b83de8b 100644 --- a/Avalonia.Desktop.slnf +++ b/Avalonia.Desktop.slnf @@ -8,9 +8,9 @@ "samples\\GpuInterop\\GpuInterop.csproj", "samples\\IntegrationTestApp\\IntegrationTestApp.csproj", "samples\\MiniMvvm\\MiniMvvm.csproj", + "samples\\ReactiveUIDemo\\ReactiveUIDemo.csproj", "samples\\SampleControls\\ControlSamples.csproj", "samples\\Sandbox\\Sandbox.csproj", - "samples\\ReactiveUIDemo\\ReactiveUIDemo.csproj", "src\\Avalonia.Base\\Avalonia.Base.csproj", "src\\Avalonia.Build.Tasks\\Avalonia.Build.Tasks.csproj", "src\\Avalonia.Controls.ColorPicker\\Avalonia.Controls.ColorPicker.csproj", @@ -38,12 +38,13 @@ "src\\Markup\\Avalonia.Markup.Xaml\\Avalonia.Markup.Xaml.csproj", "src\\Markup\\Avalonia.Markup\\Avalonia.Markup.csproj", "src\\Skia\\Avalonia.Skia\\Avalonia.Skia.csproj", - "src\\Windows\\Avalonia.Direct2D1\\Avalonia.Direct2D1.csproj", - "src\\Windows\\Avalonia.Win32.Interop\\Avalonia.Win32.Interop.csproj", - "src\\Windows\\Avalonia.Win32\\Avalonia.Win32.csproj", + "src\\tools\\Avalonia.Generators\\Avalonia.Generators.csproj", "src\\tools\\DevAnalyzers\\DevAnalyzers.csproj", "src\\tools\\DevGenerators\\DevGenerators.csproj", "src\\tools\\PublicAnalyzers\\Avalonia.Analyzers.csproj", + "src\\Windows\\Avalonia.Direct2D1\\Avalonia.Direct2D1.csproj", + "src\\Windows\\Avalonia.Win32.Interop\\Avalonia.Win32.Interop.csproj", + "src\\Windows\\Avalonia.Win32\\Avalonia.Win32.csproj", "tests\\Avalonia.Base.UnitTests\\Avalonia.Base.UnitTests.csproj", "tests\\Avalonia.Benchmarks\\Avalonia.Benchmarks.csproj", "tests\\Avalonia.Controls.DataGrid.UnitTests\\Avalonia.Controls.DataGrid.UnitTests.csproj", @@ -63,4 +64,4 @@ "tests\\Avalonia.UnitTests\\Avalonia.UnitTests.csproj" ] } -} +} \ No newline at end of file diff --git a/native/Avalonia.Native/src/OSX/platformthreading.mm b/native/Avalonia.Native/src/OSX/platformthreading.mm index 6d5bd4aa02..b727b9a6cf 100644 --- a/native/Avalonia.Native/src/OSX/platformthreading.mm +++ b/native/Avalonia.Native/src/OSX/platformthreading.mm @@ -1,193 +1,235 @@ #include "common.h" class PlatformThreadingInterface; + + +class LoopCancellation : public ComSingleObject +{ +public: + FORWARD_IUNKNOWN() + + bool Running = false; + bool Cancelled = false; + bool IsApp = false; + + virtual void Cancel() override + { + Cancelled = true; + if(Running) + { + Running = false; + if(![NSThread isMainThread]) + { + AddRef(); + dispatch_async(dispatch_get_main_queue(), ^{ + if(Release() == 0) + return; + Cancel(); + }); + return; + }; + if(IsApp) + [NSApp stop:nil]; + else + { + // Wakeup the event loop + NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined + location:NSMakePoint(0, 0) + modifierFlags:0 + timestamp:0 + windowNumber:0 + context:nil + subtype:0 + data1:0 + data2:0]; + [NSApp postEvent:event atStart:YES]; + } + } + }; +}; + +// CFRunLoopTimerSetNextFireDate docs recommend to "create a repeating timer with an initial +// firing time in the distant future (or the initial firing time) and a very large repeat +// interval—on the order of decades or more" +static double distantFutureInterval = (double)50*365*24*3600; + @interface Signaler : NSObject --(void) setParent: (PlatformThreadingInterface*)parent; --(void) signal: (int) priority; +-(void) setEvents:(IAvnPlatformThreadingInterfaceEvents*) events; +-(void) updateTimer:(int)ms; -(Signaler*) init; +-(void) destroyObserver; +-(void) signal; @end -@implementation ActionCallback +@implementation Signaler { - ComPtr _callback; - + ComPtr _events; + bool _wakeupDelegateSent; + bool _signaled; + CFRunLoopObserverRef _observer; + CFRunLoopTimerRef _timer; } -- (ActionCallback*) initWithCallback: (IAvnActionCallback*) callback + +- (Signaler*) init { - _callback = callback; + _observer = CFRunLoopObserverCreateWithHandler(nil, + kCFRunLoopBeforeSources | kCFRunLoopAfterWaiting, + true, 0, + ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) { + bool signaled; + @synchronized (self) { + signaled = self->_signaled; + } + if(signaled) + { + self->_events->Signaled(); + @synchronized (self) { + self->_signaled = false; + } + } + }); + CFRunLoopAddObserver(CFRunLoopGetMain(), _observer, kCFRunLoopCommonModes); + + + _timer = CFRunLoopTimerCreateWithHandler(nil, CFAbsoluteTimeGetCurrent() + distantFutureInterval, distantFutureInterval, 0, 0, ^(CFRunLoopTimerRef timer) { + self->_events->Timer(); + }); + + CFRunLoopAddTimer(CFRunLoopGetMain(), _timer, kCFRunLoopCommonModes); + return self; } -- (void) action +- (void) destroyObserver { - _callback->Run(); + if(_observer != nil) + { + CFRunLoopObserverInvalidate(_observer); + CFRelease(_observer); + _observer = nil; + } + + if(_timer != nil) + { + CFRunLoopTimerInvalidate(_timer); + CFRelease(_timer); + _timer = nil; + } } +-(void) updateTimer:(int)ms +{ + if(_timer == nil) + return; + double interval = ms < 0 ? distantFutureInterval : ((double)ms / 1000); + CFRunLoopTimerSetTolerance(_timer, 0); + CFRunLoopTimerSetNextFireDate(_timer, CFAbsoluteTimeGetCurrent() + interval); +} -@end +- (void) setEvents: (IAvnPlatformThreadingInterfaceEvents*) events +{ + _events = events; +} -class TimerWrapper : public ComUnknownObject +- (void) signal { - NSTimer* _timer; -public: - TimerWrapper(IAvnActionCallback* callback, int ms) - { - auto cb = [[ActionCallback alloc] initWithCallback:callback]; - _timer = [NSTimer scheduledTimerWithTimeInterval:(NSTimeInterval)(double)ms/1000 target:cb selector:@selector(action) userInfo:nullptr repeats:true]; - } - - virtual ~TimerWrapper() - { - [_timer invalidate]; + @synchronized (self) { + if(_signaled) + return; + _signaled = true; + CFRunLoopWakeUp(CFRunLoopGetMain()); } -}; +} +@end class PlatformThreadingInterface : public ComSingleObject { private: + ComPtr _events; Signaler* _signaler; - bool _wasRunningAtLeastOnce = false; - - class LoopCancellation : public ComSingleObject - { - public: - FORWARD_IUNKNOWN() - - bool Running = false; - bool Cancelled = false; - - virtual void Cancel() override - { - Cancelled = true; - if(Running) - { - Running = false; - dispatch_async(dispatch_get_main_queue(), ^{ - [[NSApplication sharedApplication] stop:nil]; - NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined - location:NSMakePoint(0, 0) - modifierFlags:0 - timestamp:0 - windowNumber:0 - context:nil - subtype:0 - data1:0 - data2:0]; - [NSApp postEvent:event atStart:YES]; - }); - } - } - - }; - + CFRunLoopObserverRef _observer = nil; public: FORWARD_IUNKNOWN() - ComPtr SignaledCallback; - PlatformThreadingInterface() { _signaler = [Signaler new]; - [_signaler setParent:this]; - } + }; ~PlatformThreadingInterface() { - if(_signaler) - [_signaler setParent: NULL]; - _signaler = NULL; + [_signaler destroyObserver]; } - virtual bool GetCurrentThreadIsLoopThread() override + bool GetCurrentThreadIsLoopThread() override { return [NSThread isMainThread]; - } - virtual void SetSignaledCallback(IAvnSignaledCallback* cb) override + }; + + bool HasPendingInput() override { - SignaledCallback = cb; - } - virtual IAvnLoopCancellation* CreateLoopCancellation() override + auto event = [NSApp + nextEventMatchingMask: NSEventMaskAny + untilDate:nil + inMode:NSDefaultRunLoopMode + dequeue:false]; + return event != nil; + }; + + void SetEvents(IAvnPlatformThreadingInterfaceEvents *cb) override + { + _events = cb; + [_signaler setEvents:cb]; + }; + + IAvnLoopCancellation *CreateLoopCancellation() override { return new LoopCancellation(); - } + }; - virtual HRESULT RunLoop(IAvnLoopCancellation* cancel) override + void RunLoop(IAvnLoopCancellation *cancel) override { START_COM_CALL; - auto can = dynamic_cast(cancel); if(can->Cancelled) - return S_OK; - if(_wasRunningAtLeastOnce) - return E_FAIL; + return; can->Running = true; - _wasRunningAtLeastOnce = true; - [NSApp run]; - return S_OK; - } + if(![NSApp isRunning]) + { + can->IsApp = true; + [NSApp run]; + return; + } + else + { + while(!can->Cancelled) + { + @autoreleasepool + { + NSEvent* ev = [NSApp + nextEventMatchingMask:NSEventMaskAny + untilDate: [NSDate dateWithTimeIntervalSinceNow:1] + inMode:NSDefaultRunLoopMode + dequeue:true]; + if(ev != NULL) + [NSApp sendEvent:ev]; + } + } + } + }; - virtual void Signal(int priority) override + void Signal() override { - [_signaler signal:priority]; - } + [_signaler signal]; + }; - virtual IUnknown* StartTimer(int priority, int ms, IAvnActionCallback* callback) override + void UpdateTimer(int ms) override { - @autoreleasepool { - - return new TimerWrapper(callback, ms); - } - } -}; - -@implementation Signaler - -PlatformThreadingInterface* _parent = 0; -bool _signaled = 0; -NSArray* _modes; - --(Signaler*) init -{ - if(self = [super init]) - { - _modes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEventTrackingRunLoopMode, NSModalPanelRunLoopMode, NSRunLoopCommonModes, NSConnectionReplyMode, nil]; - } - return self; -} - --(void) perform -{ - ComPtr cb; - @synchronized (self) { - _signaled = false; - if(_parent != NULL) - cb = _parent->SignaledCallback; - } - if(cb != nullptr) - cb->Signaled(0, false); -} - --(void) setParent:(PlatformThreadingInterface *)parent -{ - @synchronized (self) { - _parent = parent; - } -} - --(void) signal: (int) priority -{ - - @synchronized (self) { - if(_signaled) - return; - _signaled = true; - [self performSelector:@selector(perform) onThread:[NSThread mainThread] withObject:NULL waitUntilDone:false modes:_modes]; - } + [_signaler updateTimer:ms]; + }; -} -@end - +}; extern IAvnPlatformThreadingInterface* CreatePlatformThreading() { diff --git a/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs b/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs index 2cade55f32..b8ac83f418 100644 --- a/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs +++ b/src/Avalonia.Base/Threading/AvaloniaSynchronizationContext.cs @@ -30,7 +30,7 @@ namespace Avalonia.Threading /// public override void Post(SendOrPostCallback d, object? state) { - Dispatcher.UIThread.Post(d, state, DispatcherPriority.Background); + Dispatcher.UIThread.Post(() => d(state), DispatcherPriority.Background); } /// diff --git a/src/Avalonia.Base/Threading/Dispatcher.Invoke.cs b/src/Avalonia.Base/Threading/Dispatcher.Invoke.cs new file mode 100644 index 0000000000..e906931736 --- /dev/null +++ b/src/Avalonia.Base/Threading/Dispatcher.Invoke.cs @@ -0,0 +1,541 @@ +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Threading; + +namespace Avalonia.Threading; + +public partial class Dispatcher +{ + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// Note that the default priority is DispatcherPriority.Send. + /// + public void Invoke(Action callback) + { + Invoke(callback, DispatcherPriority.Send, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + public void Invoke(Action callback, DispatcherPriority priority) + { + Invoke(callback, priority, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + public void Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken) + { + Invoke(callback, priority, cancellationToken, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Action synchronously on the thread that + /// the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// The minimum amount of time to wait for the operation to start. + /// Once the operation has started, it will complete before this method + /// returns. + /// + public void Invoke(Action callback, DispatcherPriority priority, CancellationToken cancellationToken, + TimeSpan timeout) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + if (timeout.TotalMilliseconds < 0 && + timeout != TimeSpan.FromMilliseconds(-1)) + { + throw new ArgumentOutOfRangeException("timeout"); + } + + // Fast-Path: if on the same thread, and invoking at Send priority, + // and the cancellation token is not already canceled, then just + // call the callback directly. + if (!cancellationToken.IsCancellationRequested && priority == DispatcherPriority.Send && CheckAccess()) + { + callback(); + return; + } + + // Slow-Path: go through the queue. + DispatcherOperation operation = new DispatcherOperation(this, priority, callback, false); + InvokeImpl(operation, cancellationToken, timeout); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The return value from the delegate being invoked. + /// + /// + /// Note that the default priority is DispatcherPriority.Send. + /// + public TResult Invoke(Func callback) + { + return Invoke(callback, DispatcherPriority.Send, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// The return value from the delegate being invoked. + /// + public TResult Invoke(Func callback, DispatcherPriority priority) + { + return Invoke(callback, priority, CancellationToken.None, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// The return value from the delegate being invoked. + /// + public TResult Invoke(Func callback, DispatcherPriority priority, + CancellationToken cancellationToken) + { + return Invoke(callback, priority, cancellationToken, TimeSpan.FromMilliseconds(-1)); + } + + /// + /// Executes the specified Func synchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// The minimum amount of time to wait for the operation to start. + /// Once the operation has started, it will complete before this method + /// returns. + /// + /// + /// The return value from the delegate being invoked. + /// + public TResult Invoke(Func callback, DispatcherPriority priority, + CancellationToken cancellationToken, TimeSpan timeout) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + if (timeout.TotalMilliseconds < 0 && + timeout != TimeSpan.FromMilliseconds(-1)) + { + throw new ArgumentOutOfRangeException("timeout"); + } + + // Fast-Path: if on the same thread, and invoking at Send priority, + // and the cancellation token is not already canceled, then just + // call the callback directly. + if (!cancellationToken.IsCancellationRequested && priority == DispatcherPriority.Send && CheckAccess()) + { + return callback(); + } + + // Slow-Path: go through the queue. + DispatcherOperation operation = new DispatcherOperation(this, priority, callback); + return (TResult)InvokeImpl(operation, cancellationToken, timeout)!; + } + + /// + /// Executes the specified Action asynchronously on the thread + /// that the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + /// + /// Note that the default priority is DispatcherPriority.Normal. + /// + public DispatcherOperation InvokeAsync(Action callback) + { + return InvokeAsync(callback, DispatcherPriority.Normal, CancellationToken.None); + } + + /// + /// Executes the specified Action asynchronously on the thread + /// that the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority) + { + return InvokeAsync(callback, priority, CancellationToken.None); + } + + /// + /// Executes the specified Action asynchronously on the thread + /// that the Dispatcher was created on. + /// + /// + /// An Action delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority, + CancellationToken cancellationToken) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + DispatcherOperation operation = new DispatcherOperation(this, priority, callback, false); + InvokeAsyncImpl(operation, cancellationToken); + + return operation; + } + + /// + /// Executes the specified Func asynchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + /// + /// Note that the default priority is DispatcherPriority.Normal. + /// + public DispatcherOperation InvokeAsync(Func callback) + { + return InvokeAsync(callback, DispatcherPriority.Normal, CancellationToken.None); + } + + /// + /// Executes the specified Func asynchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Func callback, DispatcherPriority priority) + { + return InvokeAsync(callback, priority, CancellationToken.None); + } + + /// + /// Executes the specified Func asynchronously on the + /// thread that the Dispatcher was created on. + /// + /// + /// A Func delegate to invoke through the dispatcher. + /// + /// + /// The priority that determines in what order the specified + /// callback is invoked relative to the other pending operations + /// in the Dispatcher. + /// + /// + /// A cancellation token that can be used to cancel the operation. + /// If the operation has not started, it will be aborted when the + /// cancellation token is canceled. If the operation has started, + /// the operation can cooperate with the cancellation request. + /// + /// + /// An operation representing the queued delegate to be invoked. + /// + public DispatcherOperation InvokeAsync(Func callback, DispatcherPriority priority, + CancellationToken cancellationToken) + { + if (callback == null) + { + throw new ArgumentNullException("callback"); + } + + DispatcherPriority.Validate(priority, "priority"); + + DispatcherOperation operation = new DispatcherOperation(this, priority, callback); + InvokeAsyncImpl(operation, cancellationToken); + + return operation; + } + + private void InvokeAsyncImpl(DispatcherOperation operation, CancellationToken cancellationToken) + { + bool succeeded = false; + + // Could be a non-dispatcher thread, lock to read + lock (InstanceLock) + { + if (!cancellationToken.IsCancellationRequested && + !_hasShutdownFinished && + !Environment.HasShutdownStarted) + { + // Add the operation to the work queue + _queue.Enqueue(operation.Priority, operation); + + // Make sure we will wake up to process this operation. + succeeded = RequestProcessing(); + + if (!succeeded) + { + // Dequeue the item since we failed to request + // processing for it. Note we will mark it aborted + // below. + _queue.RemoveItem(operation); + } + } + } + + if (succeeded == true) + { + // We have enqueued the operation. Register a callback + // with the cancellation token to abort the operation + // when cancellation is requested. + if (cancellationToken.CanBeCanceled) + { + CancellationTokenRegistration cancellationRegistration = + cancellationToken.Register(s => ((DispatcherOperation)s!).Abort(), operation); + + // Revoke the cancellation when the operation is done. + operation.Aborted += (s, e) => cancellationRegistration.Dispose(); + operation.Completed += (s, e) => cancellationRegistration.Dispose(); + } + } + else + { + // We failed to enqueue the operation, and the caller that + // created the operation does not expose it before we return, + // so it is safe to modify the operation outside of the lock. + // Just mark the operation as aborted, which we can safely + // return to the user. + operation.DoAbort(); + } + } + + + private object? InvokeImpl(DispatcherOperation operation, CancellationToken cancellationToken, TimeSpan timeout) + { + object? result = null; + + Debug.Assert(timeout.TotalMilliseconds >= 0 || timeout == TimeSpan.FromMilliseconds(-1)); + Debug.Assert(operation.Priority != DispatcherPriority.Send || !CheckAccess()); // should be handled by caller + + if (!cancellationToken.IsCancellationRequested) + { + // This operation must be queued since it was invoked either to + // another thread, or at a priority other than Send. + InvokeAsyncImpl(operation, cancellationToken); + + CancellationToken ctTimeout = CancellationToken.None; + CancellationTokenRegistration ctTimeoutRegistration = new CancellationTokenRegistration(); + CancellationTokenSource? ctsTimeout = null; + + if (timeout.TotalMilliseconds >= 0) + { + // Create a CancellationTokenSource that will abort the + // operation after the timeout. Note that this does not + // cancel the operation, just abort it if it is still pending. + ctsTimeout = new CancellationTokenSource(timeout); + ctTimeout = ctsTimeout.Token; + ctTimeoutRegistration = ctTimeout.Register(s => ((DispatcherOperation)s!).Abort(), operation); + } + + + // We have already registered with the cancellation tokens + // (both provided by the user, and one for the timeout) to + // abort the operation when they are canceled. If the + // operation has already started when the timeout expires, + // we still wait for it to complete. This is different + // than simply waiting on the operation with a timeout + // because we are the ones queueing the dispatcher + // operation, not the caller. We can't leave the operation + // in a state that it might execute if we return that it did not + // invoke. + try + { + operation.GetTask().Wait(); + + Debug.Assert(operation.Status == DispatcherOperationStatus.Completed || + operation.Status == DispatcherOperationStatus.Aborted); + + // Old async semantics return from Wait without + // throwing an exception if the operation was aborted. + // There is no need to test the timout condition, since + // the old async semantics would just return the result, + // which would be null. + + // This should not block because either the operation + // is using the old async sematics, or the operation + // completed successfully. + result = operation.GetResult(); + } + catch (OperationCanceledException) + { + Debug.Assert(operation.Status == DispatcherOperationStatus.Aborted); + + // New async semantics will throw an exception if the + // operation was aborted. Here we convert that + // exception into a timeout exception if the timeout + // has expired (admittedly a weak relationship + // assuming causality). + if (ctTimeout.IsCancellationRequested) + { + // The operation was canceled because of the + // timeout, throw a TimeoutException instead. + throw new TimeoutException(); + } + else + { + // The operation was canceled from some other reason. + throw; + } + } + finally + { + ctTimeoutRegistration.Dispose(); + if (ctsTimeout != null) + { + ctsTimeout.Dispose(); + } + } + } + + return result; + } + + /// + public void Post(Action action, DispatcherPriority priority = default) + { + _ = action ?? throw new ArgumentNullException(nameof(action)); + InvokeAsyncImpl(new DispatcherOperation(this, priority, action, true), CancellationToken.None); + } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/Dispatcher.Queue.cs b/src/Avalonia.Base/Threading/Dispatcher.Queue.cs new file mode 100644 index 0000000000..bf34e80b61 --- /dev/null +++ b/src/Avalonia.Base/Threading/Dispatcher.Queue.cs @@ -0,0 +1,203 @@ +using System; +using System.Diagnostics; + +namespace Avalonia.Threading; + +public partial class Dispatcher +{ + private readonly DispatcherPriorityQueue _queue = new(); + private bool _signaled; + private DispatcherTimer? _backgroundTimer; + private const int MaximumTimeProcessingBackgroundJobs = 50; + + void RequestBackgroundProcessing() + { + if (_backgroundTimer == null) + { + _backgroundTimer = + new DispatcherTimer(this, DispatcherPriority.Send, + TimeSpan.FromMilliseconds(1)); + _backgroundTimer.Tick += delegate + { + _backgroundTimer.Stop(); + }; + } + + _backgroundTimer.IsEnabled = true; + } + + /// + /// Force-runs all dispatcher operations ignoring any pending OS events, use with caution + /// + public void RunJobs(DispatcherPriority? priority = null) + { + priority ??= DispatcherPriority.MinimumActiveValue; + if (priority < DispatcherPriority.MinimumActiveValue) + priority = DispatcherPriority.MinimumActiveValue; + while (true) + { + DispatcherOperation? job; + lock (InstanceLock) + job = _queue.Peek(); + if (job == null) + return; + if (priority != null && job.Priority < priority.Value) + return; + ExecuteJob(job); + } + } + + internal static void ResetForUnitTests() + { + if (s_uiThread == null) + return; + var st = Stopwatch.StartNew(); + while (true) + { + if (st.Elapsed.TotalSeconds > 5) + throw new InvalidProgramException("You've caused dispatcher loop"); + + DispatcherOperation? job; + lock (s_uiThread.InstanceLock) + job = s_uiThread._queue.Peek(); + if (job == null || job.Priority <= DispatcherPriority.Inactive) + { + s_uiThread = null; + return; + } + + s_uiThread.ExecuteJob(job); + } + + } + + private void ExecuteJob(DispatcherOperation job) + { + lock (InstanceLock) + _queue.RemoveItem(job); + job.Execute(); + // The backend might be firing timers with a low priority, + // so we manually check if our high priority timers are due for execution + PromoteTimers(); + } + + private void Signaled() + { + try + { + ExecuteJobsCore(); + } + finally + { + lock (InstanceLock) + _signaled = false; + } + } + + void ExecuteJobsCore() + { + int? backgroundJobExecutionStartedAt = null; + while (true) + { + DispatcherOperation? job; + + lock (InstanceLock) + job = _queue.Peek(); + + if (job == null || job.Priority < DispatcherPriority.MinimumActiveValue) + return; + + + // We don't stop for executing jobs queued with >Input priority + if (job.Priority > DispatcherPriority.Input) + { + ExecuteJob(job); + backgroundJobExecutionStartedAt = null; + } + // If platform supports pending input query, ask the platform if we can continue running low priority jobs + else if (_pendingInputImpl?.CanQueryPendingInput == true) + { + if (!_pendingInputImpl.HasPendingInput) + ExecuteJob(job); + else + { + RequestBackgroundProcessing(); + return; + } + } + // We can't check if there is pending input, but still need to enforce interactivity + // so we stop processing background jobs after some timeout and start a timer to continue later + else + { + if (backgroundJobExecutionStartedAt == null) + backgroundJobExecutionStartedAt = Clock.TickCount; + + if (Clock.TickCount - backgroundJobExecutionStartedAt.Value > MaximumTimeProcessingBackgroundJobs) + { + _signaled = true; + RequestBackgroundProcessing(); + return; + } + else + ExecuteJob(job); + } + } + } + + private bool RequestProcessing() + { + lock (InstanceLock) + { + if (_queue.MaxPriority <= DispatcherPriority.Input) + RequestBackgroundProcessing(); + else + RequestForegroundProcessing(); + } + return true; + } + + private void RequestForegroundProcessing() + { + if (!_signaled) + { + _signaled = true; + _impl.Signal(); + } + } + + internal void Abort(DispatcherOperation operation) + { + lock (InstanceLock) + _queue.RemoveItem(operation); + operation.DoAbort(); + } + + // Returns whether or not the priority was set. + internal bool SetPriority(DispatcherOperation operation, DispatcherPriority priority) // NOTE: should be Priority + { + bool notify = false; + + lock(InstanceLock) + { + if(operation.IsQueued) + { + _queue.ChangeItemPriority(operation, priority); + notify = true; + + if(notify) + { + // Make sure we will wake up to process this operation. + RequestProcessing(); + + } + } + } + return notify; + } + + public bool HasJobsWithPriority(DispatcherPriority priority) + { + lock (InstanceLock) + return _queue.MaxPriority >= priority; + } +} diff --git a/src/Avalonia.Base/Threading/Dispatcher.Timers.cs b/src/Avalonia.Base/Threading/Dispatcher.Timers.cs new file mode 100644 index 0000000000..07c063ee31 --- /dev/null +++ b/src/Avalonia.Base/Threading/Dispatcher.Timers.cs @@ -0,0 +1,171 @@ +using System; +using System.Collections.Generic; + +namespace Avalonia.Threading; + +public partial class Dispatcher +{ + private List _timers = new(); + private long _timersVersion; + private bool _dueTimeFound; + private int _dueTimeInTicks; + private bool _isOsTimerSet; + + internal void UpdateOSTimer() + { + if (!CheckAccess()) + { + Post(UpdateOSTimer, DispatcherPriority.Send); + return; + } + + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Dispatcher thread, does not technically need the lock to read + { + bool oldDueTimeFound = _dueTimeFound; + int oldDueTimeInTicks = _dueTimeInTicks; + _dueTimeFound = false; + _dueTimeInTicks = 0; + + if (_timers.Count > 0) + { + // We could do better if we sorted the list of timers. + for (int i = 0; i < _timers.Count; i++) + { + var timer = _timers[i]; + + if (!_dueTimeFound || timer.DueTimeInMs - _dueTimeInTicks < 0) + { + _dueTimeFound = true; + _dueTimeInTicks = timer.DueTimeInMs; + } + } + } + + if (_dueTimeFound) + { + if (!_isOsTimerSet || !oldDueTimeFound || (oldDueTimeInTicks != _dueTimeInTicks)) + { + _impl.UpdateTimer(Math.Max(1, _dueTimeInTicks)); + _isOsTimerSet = true; + } + } + else if (oldDueTimeFound) + { + _impl.UpdateTimer(null); + _isOsTimerSet = false; + } + } + } + } + + internal void AddTimer(DispatcherTimer timer) + { + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read + { + _timers.Add(timer); + _timersVersion++; + } + } + + UpdateOSTimer(); + } + + internal void RemoveTimer(DispatcherTimer timer) + { + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read + { + _timers.Remove(timer); + _timersVersion++; + } + } + + UpdateOSTimer(); + } + + private void OnOSTimer() + { + lock (InstanceLock) + { + _impl.UpdateTimer(null); + _isOsTimerSet = false; + } + PromoteTimers(); + } + + internal void PromoteTimers() + { + int currentTimeInTicks = Clock.TickCount; + try + { + List? timers = null; + long timersVersion = 0; + + lock (InstanceLock) + { + if (!_hasShutdownFinished) // Could be a non-dispatcher thread, lock to read + { + if (_dueTimeFound && _dueTimeInTicks - currentTimeInTicks <= 0) + { + timers = _timers; + timersVersion = _timersVersion; + } + } + } + + if (timers != null) + { + DispatcherTimer? timer = null; + int iTimer = 0; + + do + { + lock (InstanceLock) + { + timer = null; + + // If the timers collection changed while we are in the middle of + // looking for timers, start over. + if (timersVersion != _timersVersion) + { + timersVersion = _timersVersion; + iTimer = 0; + } + + while (iTimer < _timers.Count) + { + // WARNING: this is vulnerable to wrapping + if (timers[iTimer].DueTimeInMs - currentTimeInTicks <= 0) + { + // Remove this timer from our list. + // Do not increment the index. + timer = timers[iTimer]; + timers.RemoveAt(iTimer); + break; + } + else + { + iTimer++; + } + } + } + + // Now that we are outside of the lock, promote the timer. + if (timer != null) + { + timer.Promote(); + } + } while (timer != null); + } + } + finally + { + UpdateOSTimer(); + } + } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/Dispatcher.cs b/src/Avalonia.Base/Threading/Dispatcher.cs index 571f782813..14808f00a1 100644 --- a/src/Avalonia.Base/Threading/Dispatcher.cs +++ b/src/Avalonia.Base/Threading/Dispatcher.cs @@ -1,159 +1,119 @@ using System; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; using System.Threading; -using System.Threading.Tasks; using Avalonia.Platform; -namespace Avalonia.Threading +namespace Avalonia.Threading; + +/// +/// Provides services for managing work items on a thread. +/// +/// +/// In Avalonia, there is usually only a single in the application - +/// the one for the UI thread, retrieved via the property. +/// +public partial class Dispatcher : IDispatcher { - /// - /// Provides services for managing work items on a thread. - /// - /// - /// In Avalonia, there is usually only a single in the application - - /// the one for the UI thread, retrieved via the property. - /// - public class Dispatcher : IDispatcher + private readonly IDispatcherImpl _impl; + internal IDispatcherClock Clock { get; } + internal object InstanceLock { get; } = new(); + private bool _hasShutdownFinished; + private readonly IControlledDispatcherImpl? _controlledImpl; + private static Dispatcher? s_uiThread; + private readonly IDispatcherImplWithPendingInput? _pendingInputImpl; + + internal Dispatcher(IDispatcherImpl impl, IDispatcherClock clock) { - private readonly JobRunner _jobRunner; - private IPlatformThreadingInterface? _platform; - - public static Dispatcher UIThread { get; } = - new Dispatcher(AvaloniaLocator.Current.GetService()); - - public Dispatcher(IPlatformThreadingInterface? platform) - { - _platform = platform; - _jobRunner = new JobRunner(platform); - - if (_platform != null) - { - _platform.Signaled += _jobRunner.RunJobs; - } - } - - /// - /// Checks that the current thread is the UI thread. - /// - public bool CheckAccess() => _platform?.CurrentThreadIsLoopThread ?? true; - - /// - /// Checks that the current thread is the UI thread and throws if not. - /// - /// - /// The current thread is not the UI thread. - /// - public void VerifyAccess() - { - if (!CheckAccess()) - throw new InvalidOperationException("Call from invalid thread"); - } - - /// - /// Runs the dispatcher's main loop. - /// - /// - /// A cancellation token used to exit the main loop. - /// - public void MainLoop(CancellationToken cancellationToken) - { - var platform = AvaloniaLocator.Current.GetRequiredService(); - cancellationToken.Register(() => platform.Signal(DispatcherPriority.Send)); - platform.RunLoop(cancellationToken); - } - - /// - /// Runs continuations pushed on the loop. - /// - public void RunJobs() - { - _jobRunner.RunJobs(null); - } - - /// - /// Use this method to ensure that more prioritized tasks are executed - /// - /// - public void RunJobs(DispatcherPriority minimumPriority) => _jobRunner.RunJobs(minimumPriority); - - /// - /// Use this method to check if there are more prioritized tasks - /// - /// - public bool HasJobsWithPriority(DispatcherPriority minimumPriority) => - _jobRunner.HasJobsWithPriority(minimumPriority); - - /// - public Task InvokeAsync(Action action, DispatcherPriority priority = default) - { - _ = action ?? throw new ArgumentNullException(nameof(action)); - return _jobRunner.InvokeAsync(action, priority); - } - - /// - public Task InvokeAsync(Func function, DispatcherPriority priority = default) - { - _ = function ?? throw new ArgumentNullException(nameof(function)); - return _jobRunner.InvokeAsync(function, priority); - } - - /// - public Task InvokeAsync(Func function, DispatcherPriority priority = default) - { - _ = function ?? throw new ArgumentNullException(nameof(function)); - return _jobRunner.InvokeAsync(function, priority).Unwrap(); - } + _impl = impl; + Clock = clock; + impl.Timer += OnOSTimer; + impl.Signaled += Signaled; + _controlledImpl = _impl as IControlledDispatcherImpl; + _pendingInputImpl = _impl as IDispatcherImplWithPendingInput; + } + + public static Dispatcher UIThread => s_uiThread ??= CreateUIThreadDispatcher(); - /// - public Task InvokeAsync(Func> function, DispatcherPriority priority = default) + private static Dispatcher CreateUIThreadDispatcher() + { + var impl = AvaloniaLocator.Current.GetService(); + if (impl == null) { - _ = function ?? throw new ArgumentNullException(nameof(function)); - return _jobRunner.InvokeAsync(function, priority).Unwrap(); + var platformThreading = AvaloniaLocator.Current.GetService(); + if (platformThreading != null) + impl = new LegacyDispatcherImpl(platformThreading); + else + impl = new NullDispatcherImpl(); } + return new Dispatcher(impl, impl as IDispatcherClock ?? new DefaultDispatcherClock()); + } - /// - public void Post(Action action, DispatcherPriority priority = default) - { - _ = action ?? throw new ArgumentNullException(nameof(action)); - _jobRunner.Post(action, priority); - } + /// + /// Checks that the current thread is the UI thread. + /// + public bool CheckAccess() => _impl?.CurrentThreadIsLoopThread ?? true; - /// - public void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default) + /// + /// Checks that the current thread is the UI thread and throws if not. + /// + /// + /// The current thread is not the UI thread. + /// + public void VerifyAccess() + { + if (!CheckAccess()) { - _ = action ?? throw new ArgumentNullException(nameof(action)); - _jobRunner.Post(action, arg, priority); - } + // Used to inline VerifyAccess. + [DoesNotReturn] + [MethodImpl(MethodImplOptions.NoInlining)] + static void ThrowVerifyAccess() + => throw new InvalidOperationException("Call from invalid thread"); - /// - /// This is needed for platform backends that don't have internal priority system (e. g. win32) - /// To ensure that there are no jobs with higher priority - /// - /// - internal void EnsurePriority(DispatcherPriority currentPriority) - { - if (currentPriority == DispatcherPriority.MaxValue) - return; - currentPriority += 1; - _jobRunner.RunJobs(currentPriority); + ThrowVerifyAccess(); } + } - /// - /// Allows unit tests to change the platform threading interface. - /// - internal void UpdateServices() + internal void Shutdown() + { + DispatcherOperation? operation = null; + _impl.Timer -= PromoteTimers; + _impl.Signaled -= Signaled; + do { - if (_platform != null) + lock(InstanceLock) { - _platform.Signaled -= _jobRunner.RunJobs; + if(_queue.MaxPriority != DispatcherPriority.Invalid) + { + operation = _queue.Peek(); + } + else + { + operation = null; + } } - _platform = AvaloniaLocator.Current.GetService(); - _jobRunner.UpdateServices(); - - if (_platform != null) + if(operation != null) { - _platform.Signaled += _jobRunner.RunJobs; + operation.Abort(); } - } + } while(operation != null); + _impl.UpdateTimer(null); + _hasShutdownFinished = true; + } + + /// + /// Runs the dispatcher's main loop. + /// + /// + /// A cancellation token used to exit the main loop. + /// + public void MainLoop(CancellationToken cancellationToken) + { + if (_controlledImpl == null) + throw new PlatformNotSupportedException(); + cancellationToken.Register(() => RequestProcessing()); + _controlledImpl.RunLoop(cancellationToken); } } diff --git a/src/Avalonia.Base/Threading/DispatcherOperation.cs b/src/Avalonia.Base/Threading/DispatcherOperation.cs new file mode 100644 index 0000000000..5d2eab5a59 --- /dev/null +++ b/src/Avalonia.Base/Threading/DispatcherOperation.cs @@ -0,0 +1,270 @@ +using System; +using System.ComponentModel; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Threading.Tasks; + +namespace Avalonia.Threading; + +public class DispatcherOperation +{ + protected readonly bool ThrowOnUiThread; + public DispatcherOperationStatus Status { get; protected set; } + public Dispatcher Dispatcher { get; } + + public DispatcherPriority Priority + { + get => _priority; + set + { + _priority = value; + // Dispatcher is null in ctor + // ReSharper disable once ConditionalAccessQualifierIsNonNullableAccordingToAPIContract + Dispatcher?.SetPriority(this, value); + } + } + + protected object? Callback; + protected object? TaskSource; + + internal DispatcherOperation? SequentialPrev { get; set; } + internal DispatcherOperation? SequentialNext { get; set; } + internal DispatcherOperation? PriorityPrev { get; set; } + internal DispatcherOperation? PriorityNext { get; set; } + internal PriorityChain? Chain { get; set; } + + internal bool IsQueued => Chain != null; + + private EventHandler? _aborted; + private EventHandler? _completed; + private DispatcherPriority _priority; + + internal DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Action callback, bool throwOnUiThread) : + this(dispatcher, priority, throwOnUiThread) + { + Callback = callback; + } + + private protected DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, bool throwOnUiThread) + { + ThrowOnUiThread = throwOnUiThread; + Priority = priority; + Dispatcher = dispatcher; + } + + /// + /// An event that is raised when the operation is aborted or canceled. + /// + public event EventHandler Aborted + { + add + { + lock (Dispatcher.InstanceLock) + { + _aborted += value; + } + } + + remove + { + lock(Dispatcher.InstanceLock) + { + _aborted -= value; + } + } + } + + /// + /// An event that is raised when the operation completes. + /// + /// + /// Completed indicates that the operation was invoked and has + /// either completed successfully or faulted. Note that a canceled + /// or aborted operation is never is never considered completed. + /// + public event EventHandler Completed + { + add + { + lock (Dispatcher.InstanceLock) + { + _completed += value; + } + } + + remove + { + lock(Dispatcher.InstanceLock) + { + _completed -= value; + } + } + } + + public void Abort() + { + lock (Dispatcher.InstanceLock) + { + if (Status == DispatcherOperationStatus.Pending) + return; + Dispatcher.Abort(this); + } + } + + public void Wait() + { + if (Dispatcher.CheckAccess()) + throw new InvalidOperationException("Wait is only supported on background thread"); + GetTask().Wait(); + } + + public Task GetTask() => GetTaskCore(); + + /// + /// Returns an awaiter for awaiting the completion of the operation. + /// + /// + /// This method is intended to be used by compilers. + /// + [Browsable(false), EditorBrowsable(EditorBrowsableState.Never)] + public TaskAwaiter GetAwaiter() + { + return GetTask().GetAwaiter(); + } + + internal void DoAbort() + { + Status = DispatcherOperationStatus.Aborted; + AbortTask(); + _aborted?.Invoke(this, EventArgs.Empty); + } + + internal void Execute() + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Executing; + } + + try + { + InvokeCore(); + } + finally + { + _completed?.Invoke(this, EventArgs.Empty); + } + } + + protected virtual void InvokeCore() + { + try + { + ((Action)Callback!)(); + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + if (TaskSource is TaskCompletionSource tcs) + tcs.SetResult(null); + } + } + catch (Exception e) + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + if (TaskSource is TaskCompletionSource tcs) + tcs.SetException(e); + } + + if (ThrowOnUiThread) + throw; + } + } + + internal virtual object? GetResult() => null; + + protected virtual void AbortTask() => (TaskSource as TaskCompletionSource)?.SetCanceled(); + + private static CancellationToken CreateCancelledToken() + { + var cts = new CancellationTokenSource(); + cts.Cancel(); + return cts.Token; + } + + private static readonly Task s_abortedTask = Task.FromCanceled(CreateCancelledToken()); + + protected virtual Task GetTaskCore() + { + lock (Dispatcher.InstanceLock) + { + if (Status == DispatcherOperationStatus.Aborted) + return s_abortedTask; + if (Status == DispatcherOperationStatus.Completed) + return Task.CompletedTask; + if (TaskSource is not TaskCompletionSource tcs) + TaskSource = tcs = new(TaskCreationOptions.RunContinuationsAsynchronously); + return tcs.Task; + } + } +} + +public class DispatcherOperation : DispatcherOperation +{ + public DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Func callback) : base(dispatcher, priority, false) + { + TaskSource = new TaskCompletionSource(); + Callback = callback; + } + + private TaskCompletionSource TaskCompletionSource => (TaskCompletionSource)TaskSource!; + + public new Task GetTask() => TaskCompletionSource!.Task; + + protected override Task GetTaskCore() => GetTask(); + + protected override void AbortTask() => TaskCompletionSource.SetCanceled(); + + internal override object? GetResult() => GetTask().Result; + + protected override void InvokeCore() + { + try + { + var result = ((Func)Callback!)(); + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + TaskCompletionSource.SetResult(result); + } + } + catch (Exception e) + { + lock (Dispatcher.InstanceLock) + { + Status = DispatcherOperationStatus.Completed; + TaskCompletionSource.SetException(e); + } + } + } + + public T Result + { + get + { + if (TaskCompletionSource.Task.IsCompleted) + return TaskCompletionSource.Task.GetAwaiter().GetResult(); + throw new InvalidOperationException("Synchronous wait is only supported on non-UI threads"); + + } + } +} + +public enum DispatcherOperationStatus +{ + Pending = 0, + Aborted = 1, + Completed = 2, + Executing = 3, +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/DispatcherPriority.cs b/src/Avalonia.Base/Threading/DispatcherPriority.cs index b3194e249b..9d0b91f6f2 100644 --- a/src/Avalonia.Base/Threading/DispatcherPriority.cs +++ b/src/Avalonia.Base/Threading/DispatcherPriority.cs @@ -16,31 +16,49 @@ namespace Avalonia.Threading { Value = value; } - + /// - /// Minimum possible priority + /// Minimum possible priority that's actually dispatched, default value /// - public static readonly DispatcherPriority MinValue = new(0); + internal static readonly DispatcherPriority MinimumActiveValue = new(0); + /// + /// A dispatcher priority for jobs that shouldn't be executed yet + /// + public static DispatcherPriority Inactive => new(MinimumActiveValue - 1); + /// + /// Minimum valid priority + /// + internal static readonly DispatcherPriority MinValue = new(Inactive); + + /// + /// Used internally in dispatcher code + /// + public static DispatcherPriority Invalid => new(MinimumActiveValue - 2); + + + /// /// The job will be processed when the system is idle. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority SystemIdle = MinValue; + [Obsolete("WPF compatibility")] public static readonly DispatcherPriority SystemIdle = MinimumActiveValue; /// /// The job will be processed when the application is idle. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ApplicationIdle = MinValue; + [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ApplicationIdle = new (SystemIdle + 1); /// /// The job will be processed after background operations have completed. /// - [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ContextIdle = MinValue; + [Obsolete("WPF compatibility")] public static readonly DispatcherPriority ContextIdle = new(ApplicationIdle + 1); /// /// The job will be processed with normal priority. /// - public static readonly DispatcherPriority Normal = MinValue; +#pragma warning disable CS0618 + public static readonly DispatcherPriority Normal = new(ContextIdle + 1); +#pragma warning restore CS0618 /// /// The job will be processed after other non-idle operations have completed. @@ -127,5 +145,11 @@ namespace Avalonia.Threading /// public int CompareTo(DispatcherPriority other) => Value.CompareTo(other.Value); + + public static void Validate(DispatcherPriority priority, string parameterName) + { + if (priority < Inactive || priority > MaxValue) + throw new ArgumentException("Invalid DispatcherPriority value", parameterName); + } } } diff --git a/src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs b/src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs new file mode 100644 index 0000000000..524b4fab8d --- /dev/null +++ b/src/Avalonia.Base/Threading/DispatcherPriorityQueue.cs @@ -0,0 +1,418 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using Avalonia.Threading; + +namespace Avalonia.Threading; + + +internal class DispatcherPriorityQueue +{ + // Priority chains... + private readonly SortedList _priorityChains; // NOTE: should be Priority + private readonly Stack _cacheReusableChains; + + // Sequential chain... + private DispatcherOperation? _head; + private DispatcherOperation? _tail; + + public DispatcherPriorityQueue() + { + // Build the collection of priority chains. + _priorityChains = new SortedList(); // NOTE: should be Priority + _cacheReusableChains = new Stack(10); + + _head = _tail = null; + } + + // NOTE: not used + // public int Count {get{return _count;}} + + public DispatcherPriority MaxPriority // NOTE: should be Priority + { + get + { + int count = _priorityChains.Count; + + if (count > 0) + { + return _priorityChains.Keys[count - 1]; + } + else + { + return DispatcherPriority.Invalid; // NOTE: should be Priority.Invalid; + } + } + } + + public DispatcherOperation Enqueue(DispatcherPriority priority, DispatcherOperation item) // NOTE: should be Priority + { + // Find the existing chain for this priority, or create a new one + // if one does not exist. + PriorityChain chain = GetChain(priority); + + // Step 1: Append this to the end of the "sequential" linked list. + InsertItemInSequentialChain(item, _tail); + + // Step 2: Append the item into the priority chain. + InsertItemInPriorityChain(item, chain, chain.Tail); + + return item; + } + + public DispatcherOperation Dequeue() + { + // Get the max-priority chain. + int count = _priorityChains.Count; + if (count > 0) + { + PriorityChain chain = _priorityChains.Values[count - 1]; + Debug.Assert(chain != null, "PriorityQueue.Dequeue: a chain should exist."); + + DispatcherOperation? item = chain.Head; + Debug.Assert(item != null, "PriorityQueue.Dequeue: a priority item should exist."); + + RemoveItem(item); + + return item; + } + else + { + throw new InvalidOperationException(); + } + } + + public DispatcherOperation? Peek() + { + // Get the max-priority chain. + int count = _priorityChains.Count; + if (count > 0) + { + PriorityChain chain = _priorityChains.Values[count - 1]; + Debug.Assert(chain != null, "PriorityQueue.Peek: a chain should exist."); + + DispatcherOperation? item = chain.Head; + Debug.Assert(item != null, "PriorityQueue.Peek: a priority item should exist."); + + return item; + } + + return null; + } + + public void RemoveItem(DispatcherOperation item) + { + Debug.Assert(item != null, "PriorityQueue.RemoveItem: invalid item."); + Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItem: a chain should exist."); + + // Step 1: Remove the item from its priority chain. + RemoveItemFromPriorityChain(item); + + // Step 2: Remove the item from the sequential chain. + RemoveItemFromSequentialChain(item); + } + + public void ChangeItemPriority(DispatcherOperation item, DispatcherPriority priority) // NOTE: should be Priority + { + // Remove the item from its current priority and insert it into + // the new priority chain. Note that this does not change the + // sequential ordering. + + // Step 1: Remove the item from the priority chain. + RemoveItemFromPriorityChain(item); + + // Step 2: Insert the item into the new priority chain. + // Find the existing chain for this priority, or create a new one + // if one does not exist. + PriorityChain chain = GetChain(priority); + InsertItemInPriorityChain(item, chain); + } + + private PriorityChain GetChain(DispatcherPriority priority) // NOTE: should be Priority + { + PriorityChain? chain = null; + + int count = _priorityChains.Count; + if (count > 0) + { + if (priority == _priorityChains.Keys[0]) + { + chain = _priorityChains.Values[0]; + } + else if (priority == _priorityChains.Keys[count - 1]) + { + chain = _priorityChains.Values[count - 1]; + } + else if ((priority > _priorityChains.Keys[0]) && + (priority < _priorityChains.Keys[count - 1])) + { + _priorityChains.TryGetValue(priority, out chain); + } + } + + if (chain == null) + { + if (_cacheReusableChains.Count > 0) + { + chain = _cacheReusableChains.Pop(); + chain.Priority = priority; + } + else + { + chain = new PriorityChain(priority); + } + + _priorityChains.Add(priority, chain); + } + + return chain; + } + + private void InsertItemInPriorityChain(DispatcherOperation item, PriorityChain chain) + { + // Scan along the sequential chain, in the previous direction, + // looking for an item that is already in the new chain. We will + // insert ourselves after the item we found. We can short-circuit + // this search if the new chain is empty. + if (chain.Head == null) + { + Debug.Assert(chain.Tail == null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should be null."); + InsertItemInPriorityChain(item, chain, null); + } + else + { + Debug.Assert(chain.Tail != null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should not be null."); + + DispatcherOperation? after; + + // Search backwards along the sequential chain looking for an + // item already in this list. + for (after = item.SequentialPrev; after != null; after = after.SequentialPrev) + { + if (after.Chain == chain) + { + break; + } + } + + InsertItemInPriorityChain(item, chain, after); + } + } + + internal void InsertItemInPriorityChain(DispatcherOperation item, PriorityChain chain, DispatcherOperation? after) + { + Debug.Assert(chain != null, "PriorityQueue.InsertItemInPriorityChain: a chain must be provided."); + Debug.Assert(item.Chain == null && item.PriorityPrev == null && item.PriorityNext == null, + "PriorityQueue.InsertItemInPriorityChain: item must not already be in a priority chain."); + + item.Chain = chain; + + if (after == null) + { + // Note: passing null for after means insert at the head. + + if (chain.Head != null) + { + Debug.Assert(chain.Tail != null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should not be null."); + + chain.Head.PriorityPrev = item; + item.PriorityNext = chain.Head; + chain.Head = item; + } + else + { + Debug.Assert(chain.Tail == null, + "PriorityQueue.InsertItemInPriorityChain: both the head and the tail should be null."); + + chain.Head = chain.Tail = item; + } + } + else + { + item.PriorityPrev = after; + + if (after.PriorityNext != null) + { + item.PriorityNext = after.PriorityNext; + after.PriorityNext.PriorityPrev = item; + after.PriorityNext = item; + } + else + { + Debug.Assert(item.Chain.Tail == after, + "PriorityQueue.InsertItemInPriorityChain: the chain's tail should be the item we are inserting after."); + after.PriorityNext = item; + chain.Tail = item; + } + } + + chain.Count++; + } + + private void RemoveItemFromPriorityChain(DispatcherOperation item) + { + Debug.Assert(item != null, "PriorityQueue.RemoveItemFromPriorityChain: invalid item."); + Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItemFromPriorityChain: a chain should exist."); + + // Step 1: Fix up the previous link + if (item.PriorityPrev != null) + { + Debug.Assert(item.Chain.Head != item, + "PriorityQueue.RemoveItemFromPriorityChain: the head should not point to this item."); + + item.PriorityPrev.PriorityNext = item.PriorityNext; + } + else + { + Debug.Assert(item.Chain.Head == item, + "PriorityQueue.RemoveItemFromPriorityChain: the head should point to this item."); + + item.Chain.Head = item.PriorityNext; + } + + // Step 2: Fix up the next link + if (item.PriorityNext != null) + { + Debug.Assert(item.Chain.Tail != item, + "PriorityQueue.RemoveItemFromPriorityChain: the tail should not point to this item."); + + item.PriorityNext.PriorityPrev = item.PriorityPrev; + } + else + { + Debug.Assert(item.Chain.Tail == item, + "PriorityQueue.RemoveItemFromPriorityChain: the tail should point to this item."); + + item.Chain.Tail = item.PriorityPrev; + } + + // Step 3: cleanup + item.PriorityPrev = item.PriorityNext = null; + item.Chain.Count--; + if (item.Chain.Count == 0) + { + if (item.Chain.Priority == _priorityChains.Keys[_priorityChains.Count - 1]) + { + _priorityChains.RemoveAt(_priorityChains.Count - 1); + } + else + { + _priorityChains.Remove(item.Chain.Priority); + } + + if (_cacheReusableChains.Count < 10) + { + item.Chain.Priority = DispatcherPriority.Invalid; + _cacheReusableChains.Push(item.Chain); + } + } + + item.Chain = null; + } + + internal void InsertItemInSequentialChain(DispatcherOperation item, DispatcherOperation? after) + { + Debug.Assert(item.SequentialPrev == null && item.SequentialNext == null, + "PriorityQueue.InsertItemInSequentialChain: item must not already be in the sequential chain."); + + if (after == null) + { + // Note: passing null for after means insert at the head. + + if (_head != null) + { + Debug.Assert(_tail != null, + "PriorityQueue.InsertItemInSequentialChain: both the head and the tail should not be null."); + + _head.SequentialPrev = item; + item.SequentialNext = _head; + _head = item; + } + else + { + Debug.Assert(_tail == null, + "PriorityQueue.InsertItemInSequentialChain: both the head and the tail should be null."); + + _head = _tail = item; + } + } + else + { + item.SequentialPrev = after; + + if (after.SequentialNext != null) + { + item.SequentialNext = after.SequentialNext; + after.SequentialNext.SequentialPrev = item; + after.SequentialNext = item; + } + else + { + Debug.Assert(_tail == after, + "PriorityQueue.InsertItemInSequentialChain: the tail should be the item we are inserting after."); + after.SequentialNext = item; + _tail = item; + } + } + } + + private void RemoveItemFromSequentialChain(DispatcherOperation item) + { + Debug.Assert(item != null, "PriorityQueue.RemoveItemFromSequentialChain: invalid item."); + + // Step 1: Fix up the previous link + if (item.SequentialPrev != null) + { + Debug.Assert(_head != item, + "PriorityQueue.RemoveItemFromSequentialChain: the head should not point to this item."); + + item.SequentialPrev.SequentialNext = item.SequentialNext; + } + else + { + Debug.Assert(_head == item, + "PriorityQueue.RemoveItemFromSequentialChain: the head should point to this item."); + + _head = item.SequentialNext; + } + + // Step 2: Fix up the next link + if (item.SequentialNext != null) + { + Debug.Assert(_tail != item, + "PriorityQueue.RemoveItemFromSequentialChain: the tail should not point to this item."); + + item.SequentialNext.SequentialPrev = item.SequentialPrev; + } + else + { + Debug.Assert(_tail == item, + "PriorityQueue.RemoveItemFromSequentialChain: the tail should point to this item."); + + _tail = item.SequentialPrev; + } + + // Step 3: cleanup + item.SequentialPrev = item.SequentialNext = null; + } +} + + +internal class PriorityChain +{ + public PriorityChain(DispatcherPriority priority) // NOTE: should be Priority + { + Priority = priority; + } + + public DispatcherPriority Priority { get; set; } // NOTE: should be Priority + + public int Count { get; set; } + + public DispatcherOperation? Head { get; set; } + + public DispatcherOperation? Tail { get; set; } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/DispatcherTimer.cs b/src/Avalonia.Base/Threading/DispatcherTimer.cs index f81229eb48..183f66eb61 100644 --- a/src/Avalonia.Base/Threading/DispatcherTimer.cs +++ b/src/Avalonia.Base/Threading/DispatcherTimer.cs @@ -1,207 +1,352 @@ using System; using Avalonia.Reactive; -using Avalonia.Platform; -namespace Avalonia.Threading +namespace Avalonia.Threading; + +/// +/// A timer that is integrated into the Dispatcher queues, and will +/// be processed after a given amount of time at a specified priority. +/// +public partial class DispatcherTimer { /// - /// A timer that uses a to fire at a specified interval. + /// Creates a timer that uses theUI thread's Dispatcher2 to + /// process the timer event at background priority. /// - public class DispatcherTimer + public DispatcherTimer() : this(DispatcherPriority.Background) { - private IDisposable? _timer; + } - private readonly DispatcherPriority _priority; + /// + /// Creates a timer that uses the UI thread's Dispatcher2 to + /// process the timer event at the specified priority. + /// + /// + /// The priority to process the timer at. + /// + public DispatcherTimer(DispatcherPriority priority) : this(Threading.Dispatcher.UIThread, priority, + TimeSpan.FromMilliseconds(0)) + { + } - private TimeSpan _interval; + /// + /// Creates a timer that uses the specified Dispatcher2 to + /// process the timer event at the specified priority. + /// + /// + /// The priority to process the timer at. + /// + /// + /// The dispatcher to use to process the timer. + /// + internal DispatcherTimer(DispatcherPriority priority, Dispatcher dispatcher) : this(dispatcher, priority, + TimeSpan.FromMilliseconds(0)) + { + } - /// - /// Initializes a new instance of the class. - /// - public DispatcherTimer() : this(DispatcherPriority.Background) + /// + /// Creates a timer that uses the UI thread's Dispatcher2 to + /// process the timer event at the specified priority after the specified timeout. + /// + /// + /// The interval to tick the timer after. + /// + /// + /// The priority to process the timer at. + /// + /// + /// The callback to call when the timer ticks. + /// + public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback) + : this(Threading.Dispatcher.UIThread, priority, interval) + { + if (callback == null) { + throw new ArgumentNullException("callback"); } - /// - /// Initializes a new instance of the class. - /// - /// The priority to use. - public DispatcherTimer(DispatcherPriority priority) - { - _priority = priority; - } + Tick += callback; + Start(); + } - /// - /// Initializes a new instance of the class. - /// - /// The interval at which to tick. - /// The priority to use. - /// The event to call when the timer ticks. - public DispatcherTimer(TimeSpan interval, DispatcherPriority priority, EventHandler callback) : this(priority) - { - _priority = priority; - Interval = interval; - Tick += callback; - } + /// + /// Gets the dispatcher this timer is associated with. + /// + public Dispatcher Dispatcher + { + get { return _dispatcher; } + } - /// - /// Finalizes an instance of the class. - /// - ~DispatcherTimer() + /// + /// Gets or sets whether the timer is running. + /// + public bool IsEnabled + { + get { return _isEnabled; } + + set { - if (_timer != null) + lock (_instanceLock) { - Stop(); + if (!value && _isEnabled) + { + Stop(); + } + else if (value && !_isEnabled) + { + Start(); + } } } + } - /// - /// Raised when the timer ticks. - /// - public event EventHandler? Tick; + /// + /// Gets or sets the time between timer ticks. + /// + public TimeSpan Interval + { + get { return _interval; } - /// - /// Gets or sets the interval at which the timer ticks. - /// - public TimeSpan Interval + set { - get + bool updateOSTimer = false; + + if (value.TotalMilliseconds < 0) + throw new ArgumentOutOfRangeException("value", + "TimeSpan period must be greater than or equal to zero."); + + if (value.TotalMilliseconds > Int32.MaxValue) + throw new ArgumentOutOfRangeException("value", + "TimeSpan period must be less than or equal to Int32.MaxValue."); + + lock (_instanceLock) { - return _interval; + _interval = value; + + if (_isEnabled) + { + DueTimeInMs = _dispatcher.Clock.TickCount + (int)_interval.TotalMilliseconds; + updateOSTimer = true; + } } - set + if (updateOSTimer) { - bool enabled = IsEnabled; - Stop(); - _interval = value; - IsEnabled = enabled; + _dispatcher.UpdateOSTimer(); } } + } - /// - /// Gets or sets a value indicating whether the timer is running. - /// - public bool IsEnabled + /// + /// Starts the timer. + /// + public void Start() + { + lock (_instanceLock) { - get + if (!_isEnabled) { - return _timer != null; + _isEnabled = true; + + Restart(); } + } + } - set + /// + /// Stops the timer. + /// + public void Stop() + { + bool updateOSTimer = false; + + lock (_instanceLock) + { + if (_isEnabled) { - if (IsEnabled != value) + _isEnabled = false; + updateOSTimer = true; + + // If the operation is in the queue, abort it. + if (_operation != null) { - if (value) - { - Start(); - } - else - { - Stop(); - } + _operation.Abort(); + _operation = null; } } } - /// - /// Gets or sets user-defined data associated with the timer. - /// - public object? Tag + if (updateOSTimer) { - get; - set; + _dispatcher.RemoveTimer(this); } + } + + /// + /// Starts a new timer. + /// + /// + /// The method to call on timer tick. If the method returns false, the timer will stop. + /// + /// The interval at which to tick. + /// The priority to use. + /// An used to cancel the timer. + public static IDisposable Run(Func action, TimeSpan interval, DispatcherPriority priority = default) + { + var timer = new DispatcherTimer(priority) { Interval = interval }; - /// - /// Starts a new timer. - /// - /// - /// The method to call on timer tick. If the method returns false, the timer will stop. - /// - /// The interval at which to tick. - /// The priority to use. - /// An used to cancel the timer. - public static IDisposable Run(Func action, TimeSpan interval, DispatcherPriority priority = default) + timer.Tick += (s, e) => { - var timer = new DispatcherTimer(priority) { Interval = interval }; - - timer.Tick += (s, e) => + if (!action()) { - if (!action()) - { - timer.Stop(); - } - }; + timer.Stop(); + } + }; - timer.Start(); + timer.Start(); - return Disposable.Create(() => timer.Stop()); - } + return Disposable.Create(() => timer.Stop()); + } + + /// + /// Runs a method once, after the specified interval. + /// + /// + /// The method to call after the interval has elapsed. + /// + /// The interval after which to call the method. + /// The priority to use. + /// An used to cancel the timer. + public static IDisposable RunOnce( + Action action, + TimeSpan interval, + DispatcherPriority priority = default) + { + interval = (interval != TimeSpan.Zero) ? interval : TimeSpan.FromTicks(1); + + var timer = new DispatcherTimer(priority) { Interval = interval }; - /// - /// Runs a method once, after the specified interval. - /// - /// - /// The method to call after the interval has elapsed. - /// - /// The interval after which to call the method. - /// The priority to use. - /// An used to cancel the timer. - public static IDisposable RunOnce( - Action action, - TimeSpan interval, - DispatcherPriority priority = default) + timer.Tick += (s, e) => { - interval = (interval != TimeSpan.Zero) ? interval : TimeSpan.FromTicks(1); - - var timer = new DispatcherTimer(priority) { Interval = interval }; + action(); + timer.Stop(); + }; + + timer.Start(); + + return Disposable.Create(() => timer.Stop()); + } + + /// + /// Occurs when the specified timer interval has elapsed and the + /// timer is enabled. + /// + public event EventHandler? Tick; + + /// + /// Any data that the caller wants to pass along with the timer. + /// + public object? Tag { get; set; } - timer.Tick += (s, e) => - { - action(); - timer.Stop(); - }; - timer.Start(); + internal DispatcherTimer(Dispatcher dispatcher, DispatcherPriority priority, TimeSpan interval) + { + if (dispatcher == null) + { + throw new ArgumentNullException("dispatcher"); + } - return Disposable.Create(() => timer.Stop()); + DispatcherPriority.Validate(priority, "priority"); + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("Specified priority is not valid.", "priority"); } - /// - /// Starts the timer. - /// - public void Start() + if (interval.TotalMilliseconds < 0) + throw new ArgumentOutOfRangeException("interval", "TimeSpan period must be greater than or equal to zero."); + + if (interval.TotalMilliseconds > Int32.MaxValue) + throw new ArgumentOutOfRangeException("interval", + "TimeSpan period must be less than or equal to Int32.MaxValue."); + + + _dispatcher = dispatcher; + _priority = priority; + _interval = interval; + } + + private void Restart() + { + lock (_instanceLock) { - if (!IsEnabled) + if (_operation != null) { - var threading = AvaloniaLocator.Current.GetRequiredService(); - _timer = threading.StartTimer(_priority, Interval, InternalTick); + // Timer has already been restarted, e.g. Start was called form the Tick handler. + return; + } + + // BeginInvoke a new operation. + _operation = _dispatcher.InvokeAsync(FireTick, DispatcherPriority.Inactive); + + DueTimeInMs = _dispatcher.Clock.TickCount + (int)_interval.TotalMilliseconds; + + if (_interval.TotalMilliseconds == 0 && _dispatcher.CheckAccess()) + { + // shortcut - just promote the item now + Promote(); + } + else + { + _dispatcher.AddTimer(this); } } + } - /// - /// Stops the timer. - /// - public void Stop() + internal void Promote() // called from Dispatcher + { + lock (_instanceLock) { - if (IsEnabled) + // Simply promote the operation to it's desired priority. + if (_operation != null) { - _timer!.Dispose(); - _timer = null; + _operation.Priority = _priority; } } + } + private void FireTick() + { + // The operation has been invoked, so forget about it. + _operation = null; + // The dispatcher thread is calling us because item's priority + // was changed from inactive to something else. + if (Tick != null) + { + Tick(this, EventArgs.Empty); + } - /// - /// Raises the event on the dispatcher thread. - /// - private void InternalTick() + // If we are still enabled, start the timer again. + if (_isEnabled) { - Dispatcher.UIThread.EnsurePriority(_priority); - Tick?.Invoke(this, EventArgs.Empty); + Restart(); } } -} + + // This is the object we use to synchronize access. + private object _instanceLock = new object(); + + // Note: We cannot BE a dispatcher-affinity object because we can be + // created by a worker thread. We are still associated with a + // dispatcher (where we post the item) but we can be accessed + // by any thread. + private Dispatcher _dispatcher; + + private DispatcherPriority _priority; // NOTE: should be Priority + private TimeSpan _interval; + private DispatcherOperation? _operation; + private bool _isEnabled; + + // used by Dispatcher + internal int DueTimeInMs { get; private set; } +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/IDispatcher.cs b/src/Avalonia.Base/Threading/IDispatcher.cs index 1c700132b7..e2a3115f9c 100644 --- a/src/Avalonia.Base/Threading/IDispatcher.cs +++ b/src/Avalonia.Base/Threading/IDispatcher.cs @@ -26,30 +26,5 @@ namespace Avalonia.Threading /// The method. /// The priority with which to invoke the method. void Post(Action action, DispatcherPriority priority = default); - - /// - /// Posts an action that will be invoked on the dispatcher thread. - /// - /// The method. - /// The argument of method to call. - /// The priority with which to invoke the method. - void Post(SendOrPostCallback action, object? arg, DispatcherPriority priority = default); - - /// - /// Invokes a action on the dispatcher thread. - /// - /// The method. - /// The priority with which to invoke the method. - /// A task that can be used to track the method's execution. - Task InvokeAsync(Action action, DispatcherPriority priority = default); - - /// - /// Queues the specified work to run on the dispatcher thread and returns a proxy for the - /// task returned by . - /// - /// The work to execute asynchronously. - /// The priority with which to invoke the method. - /// A task that represents a proxy for the task returned by . - Task InvokeAsync(Func function, DispatcherPriority priority = default); } } diff --git a/src/Avalonia.Base/Threading/IDispatcherClock.cs b/src/Avalonia.Base/Threading/IDispatcherClock.cs new file mode 100644 index 0000000000..2a5268d192 --- /dev/null +++ b/src/Avalonia.Base/Threading/IDispatcherClock.cs @@ -0,0 +1,13 @@ +using System; + +namespace Avalonia.Threading; + +internal interface IDispatcherClock +{ + int TickCount { get; } +} + +internal class DefaultDispatcherClock : IDispatcherClock +{ + public int TickCount => Environment.TickCount; +} \ No newline at end of file diff --git a/src/Avalonia.Base/Threading/IDispatcherImpl.cs b/src/Avalonia.Base/Threading/IDispatcherImpl.cs new file mode 100644 index 0000000000..5d83ced011 --- /dev/null +++ b/src/Avalonia.Base/Threading/IDispatcherImpl.cs @@ -0,0 +1,90 @@ +using System; +using System.Threading; +using Avalonia.Platform; + +namespace Avalonia.Threading; + +interface IDispatcherImpl +{ + + //IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick); + + bool CurrentThreadIsLoopThread { get; } + + // Asynchronously triggers Signaled callback + void Signal(); + event Action Signaled; + event Action Timer; + void UpdateTimer(int? dueTimeInTicks); +} + + +interface IDispatcherImplWithPendingInput : IDispatcherImpl +{ + // Checks if dispatcher implementation can + bool CanQueryPendingInput { get; } + // Checks if there is pending user input + bool HasPendingInput { get; } +} + +interface IControlledDispatcherImpl : IDispatcherImplWithPendingInput +{ + // Runs the event loop + void RunLoop(CancellationToken token); +} + +internal class LegacyDispatcherImpl : IControlledDispatcherImpl +{ + private readonly IPlatformThreadingInterface _platformThreading; + private IDisposable? _timer; + + public LegacyDispatcherImpl(IPlatformThreadingInterface platformThreading) + { + _platformThreading = platformThreading; + _platformThreading.Signaled += delegate { Signaled?.Invoke(); }; + } + + public bool CurrentThreadIsLoopThread => _platformThreading.CurrentThreadIsLoopThread; + public void Signal() => _platformThreading.Signal(DispatcherPriority.Send); + + public event Action? Signaled; + public event Action? Timer; + public void UpdateTimer(int? dueTimeInTicks) + { + _timer?.Dispose(); + _timer = null; + if (dueTimeInTicks.HasValue) + _timer = _platformThreading.StartTimer(DispatcherPriority.Send, + TimeSpan.FromMilliseconds(dueTimeInTicks.Value), + OnTick); + } + + private void OnTick() + { + _timer?.Dispose(); + _timer = null; + Timer?.Invoke(); + } + + public bool CanQueryPendingInput => false; + public bool HasPendingInput => false; + public void RunLoop(CancellationToken token) => _platformThreading.RunLoop(token); +} + +class NullDispatcherImpl : IDispatcherImpl +{ + public bool CurrentThreadIsLoopThread => true; + + public void Signal() + { + + } + + public event Action? Signaled; + public event Action? Timer; + + public void UpdateTimer(int? dueTimeInTicks) + { + + } +} diff --git a/src/Avalonia.Base/Threading/JobRunner.cs b/src/Avalonia.Base/Threading/JobRunner.cs index ced3423c27..b2b4f876d1 100644 --- a/src/Avalonia.Base/Threading/JobRunner.cs +++ b/src/Avalonia.Base/Threading/JobRunner.cs @@ -28,7 +28,7 @@ namespace Avalonia.Threading /// Priority to execute jobs for. Pass null if platform doesn't have internal priority system public void RunJobs(DispatcherPriority? priority) { - var minimumPriority = priority ?? DispatcherPriority.MinValue; + var minimumPriority = priority ?? DispatcherPriority.MinimumActiveValue; while (true) { var job = GetNextJob(minimumPriority); diff --git a/src/Avalonia.Native/AvaloniaNativePlatform.cs b/src/Avalonia.Native/AvaloniaNativePlatform.cs index 67b55bd512..e6a103f6b9 100644 --- a/src/Avalonia.Native/AvaloniaNativePlatform.cs +++ b/src/Avalonia.Native/AvaloniaNativePlatform.cs @@ -9,6 +9,7 @@ using Avalonia.OpenGL; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; +using Avalonia.Threading; using MicroCom.Runtime; #nullable enable @@ -98,8 +99,8 @@ namespace Avalonia.Native } AvaloniaLocator.CurrentMutable - .Bind() - .ToConstant(new PlatformThreadingInterface(_factory.CreatePlatformThreadingInterface())) + .Bind() + .ToConstant(new DispatcherImpl(_factory.CreatePlatformThreadingInterface())) .Bind().ToConstant(new CursorFactory(_factory.CreateCursorFactory())) .Bind().ToSingleton() .Bind().ToConstant(KeyboardDevice) diff --git a/src/Avalonia.Native/CallbackBase.cs b/src/Avalonia.Native/CallbackBase.cs index 9f59c97f9b..c5978e2a0d 100644 --- a/src/Avalonia.Native/CallbackBase.cs +++ b/src/Avalonia.Native/CallbackBase.cs @@ -2,6 +2,7 @@ using System.Runtime.ExceptionServices; using Avalonia.MicroCom; using Avalonia.Platform; +using Avalonia.Threading; using MicroCom.Runtime; namespace Avalonia.Native @@ -10,11 +11,9 @@ namespace Avalonia.Native { public void RaiseException(Exception e) { - if (AvaloniaLocator.Current.GetService() is PlatformThreadingInterface threadingInterface) + if (AvaloniaLocator.Current.GetService() is DispatcherImpl dispatcherImpl) { - threadingInterface.TerminateNativeApp(); - - threadingInterface.DispatchException(ExceptionDispatchInfo.Capture(e)); + dispatcherImpl.PropagateCallbackException(ExceptionDispatchInfo.Capture(e)); } } } diff --git a/src/Avalonia.Native/DispatcherImpl.cs b/src/Avalonia.Native/DispatcherImpl.cs new file mode 100644 index 0000000000..4788dd5e82 --- /dev/null +++ b/src/Avalonia.Native/DispatcherImpl.cs @@ -0,0 +1,127 @@ +#nullable enable +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.ExceptionServices; +using System.Threading; +using Avalonia.Native.Interop; +using Avalonia.Threading; +using MicroCom.Runtime; + +namespace Avalonia.Native; + +internal class DispatcherImpl : IControlledDispatcherImpl, IDispatcherClock +{ + private readonly IAvnPlatformThreadingInterface _native; + private Thread? _loopThread; + private Stack _managedFrames = new(); + + public DispatcherImpl(IAvnPlatformThreadingInterface native) + { + _native = native; + using var events = new Events(this); + _native.SetEvents(events); + } + + public event Action Signaled; + public event Action Timer; + + private class Events : NativeCallbackBase, IAvnPlatformThreadingInterfaceEvents + { + private readonly DispatcherImpl _parent; + + public Events(DispatcherImpl parent) + { + _parent = parent; + } + public void Signaled() => _parent.Signaled?.Invoke(); + + public void Timer() => _parent.Timer?.Invoke(); + } + + public bool CurrentThreadIsLoopThread + { + get + { + if (_loopThread != null) + return Thread.CurrentThread == _loopThread; + if (_native.CurrentThreadIsLoopThread == 0) + return false; + _loopThread = Thread.CurrentThread; + return true; + } + } + + public void Signal() => _native.Signal(); + + public void UpdateTimer(int? dueTimeInTicks) + { + var ms = dueTimeInTicks == null ? -1 : Math.Max(1, dueTimeInTicks.Value - TickCount); + _native.UpdateTimer(ms); + } + + public bool CanQueryPendingInput => true; + public bool HasPendingInput => _native.HasPendingInput() != 0; + + class RunLoopFrame : IDisposable + { + public ExceptionDispatchInfo? Exception; + public CancellationTokenSource CancellationTokenSource = new(); + + public RunLoopFrame(CancellationToken token) + { + CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token); + } + + public void Dispose() => CancellationTokenSource.Dispose(); + } + + public void RunLoop(CancellationToken token) + { + if (token.IsCancellationRequested) + return; + object l = new(); + var exited = false; + + using var frame = new RunLoopFrame(token); + + using var cancel = _native.CreateLoopCancellation(); + frame.CancellationTokenSource.Token.Register(() => + { + lock (l) + // ReSharper disable once AccessToModifiedClosure + // ReSharper disable once AccessToDisposedClosure + if (!exited) + cancel.Cancel(); + }); + + try + { + _managedFrames.Push(frame); + _native.RunLoop(cancel); + } + finally + { + lock (l) + exited = true; + _managedFrames.Pop(); + if (frame.Exception != null) + frame.Exception.Throw(); + } + } + + public int TickCount => Environment.TickCount; + + public void PropagateCallbackException(ExceptionDispatchInfo capture) + { + if (_managedFrames.Count == 0) + { + Debug.Assert(false, "We should never get here"); + return; + } + + var frame = _managedFrames.Peek(); + frame.Exception = capture; + frame.CancellationTokenSource.Cancel(); + } +} diff --git a/src/Avalonia.Native/PlatformThreadingInterface.cs b/src/Avalonia.Native/PlatformThreadingInterface.cs deleted file mode 100644 index 99aa8a5850..0000000000 --- a/src/Avalonia.Native/PlatformThreadingInterface.cs +++ /dev/null @@ -1,115 +0,0 @@ -using System; -using System.Runtime.ExceptionServices; -using System.Threading; -using Avalonia.Native.Interop; -using Avalonia.Platform; -using Avalonia.Threading; - -namespace Avalonia.Native -{ - internal class PlatformThreadingInterface : IPlatformThreadingInterface - { - class TimerCallback : NativeCallbackBase, IAvnActionCallback - { - readonly Action _tick; - - public TimerCallback(Action tick) - { - _tick = tick; - } - - public void Run() - { - _tick(); - } - } - - class SignaledCallback : NativeCallbackBase, IAvnSignaledCallback - { - readonly PlatformThreadingInterface _parent; - - public SignaledCallback(PlatformThreadingInterface parent) - { - _parent = parent; - } - - public void Signaled(int priority, int priorityContainsMeaningfulValue) - { - _parent.Signaled?.Invoke(priorityContainsMeaningfulValue.FromComBool() ? (DispatcherPriority?)priority : null); - } - } - - readonly IAvnPlatformThreadingInterface _native; - private ExceptionDispatchInfo _exceptionDispatchInfo; - private CancellationTokenSource _exceptionCancellationSource; - - public PlatformThreadingInterface(IAvnPlatformThreadingInterface native) - { - _native = native; - using (var cb = new SignaledCallback(this)) - _native.SetSignaledCallback(cb); - } - - public bool CurrentThreadIsLoopThread => _native.CurrentThreadIsLoopThread.FromComBool(); - - public event Action Signaled; - - public void RunLoop(CancellationToken cancellationToken) - { - _exceptionDispatchInfo?.Throw(); - var l = new object(); - _exceptionCancellationSource = new CancellationTokenSource(); - - var compositeCancellation = CancellationTokenSource - .CreateLinkedTokenSource(cancellationToken, _exceptionCancellationSource.Token).Token; - - var cancellation = _native.CreateLoopCancellation(); - compositeCancellation.Register(() => - { - lock (l) - { - cancellation?.Cancel(); - } - }); - - try - { - _native.RunLoop(cancellation); - } - finally - { - lock (l) - { - cancellation?.Dispose(); - cancellation = null; - } - } - - if (_exceptionDispatchInfo != null) - { - _exceptionDispatchInfo.Throw(); - } - } - - public void DispatchException (ExceptionDispatchInfo exceptionInfo) - { - _exceptionDispatchInfo = exceptionInfo; - } - - public void TerminateNativeApp() - { - _exceptionCancellationSource?.Cancel(); - } - - public void Signal(DispatcherPriority priority) - { - _native.Signal((int)priority); - } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) - { - using (var cb = new TimerCallback(tick)) - return _native.StartTimer((int)priority, (int)interval.TotalMilliseconds, cb); - } - } -} diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl index b107e83e7a..7763d0d2fc 100644 --- a/src/Avalonia.Native/avn.idl +++ b/src/Avalonia.Native/avn.idl @@ -645,9 +645,10 @@ interface IAvnActionCallback : IUnknown } [uuid(6df4d2db-0b80-4f59-ad88-0baa5e21eb14)] -interface IAvnSignaledCallback : IUnknown +interface IAvnPlatformThreadingInterfaceEvents : IUnknown { - void Signaled(int priority, bool priorityContainsMeaningfulValue); + void Signaled(); + void Timer(); } [uuid(97330f88-c22b-4a8e-a130-201520091b01)] @@ -660,12 +661,12 @@ interface IAvnLoopCancellation : IUnknown interface IAvnPlatformThreadingInterface : IUnknown { bool GetCurrentThreadIsLoopThread(); - void SetSignaledCallback(IAvnSignaledCallback* cb); + bool HasPendingInput(); + void SetEvents(IAvnPlatformThreadingInterfaceEvents* cb); IAvnLoopCancellation* CreateLoopCancellation(); - HRESULT RunLoop(IAvnLoopCancellation* cancel); - // Can't pass int* to sharpgentools for some reason - void Signal(int priority); - IUnknown* StartTimer(int priority, int ms, IAvnActionCallback* callback); + void RunLoop(IAvnLoopCancellation* cancel); + void Signal(); + void UpdateTimer(int ms); } [uuid(6c621a6e-e4c1-4ae3-9749-83eeeffa09b6)] diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs index 170c6ce6b3..e4e5dbfcb8 100644 --- a/src/Avalonia.X11/X11Platform.cs +++ b/src/Avalonia.X11/X11Platform.cs @@ -14,6 +14,7 @@ using Avalonia.OpenGL.Egl; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; +using Avalonia.Threading; using Avalonia.X11; using Avalonia.X11.Glx; using static Avalonia.X11.XLib; @@ -34,6 +35,7 @@ namespace Avalonia.X11 public X11PlatformOptions Options { get; private set; } public IntPtr OrphanedWindow { get; private set; } public X11Globals Globals { get; private set; } + public ManualRawEventGrouperDispatchQueue EventGrouperDispatchQueue { get; } = new(); [DllImport("libc")] private static extern void setlocale(int type, string s); public void Initialize(X11PlatformOptions options) @@ -72,7 +74,7 @@ namespace Avalonia.X11 AvaloniaLocator.CurrentMutable.BindToSelf(this) .Bind().ToConstant(this) - .Bind().ToConstant(new X11PlatformThreading(this)) + .Bind().ToConstant(new X11PlatformThreading(this)) .Bind().ToConstant(new SleepLoopRenderTimer(60)) .Bind().ToConstant(new RenderLoop()) .Bind().ToConstant(new PlatformHotkeyConfiguration(KeyModifiers.Control)) diff --git a/src/Avalonia.X11/X11PlatformThreading.cs b/src/Avalonia.X11/X11PlatformThreading.cs index 1946642de3..b8a5b68658 100644 --- a/src/Avalonia.X11/X11PlatformThreading.cs +++ b/src/Avalonia.X11/X11PlatformThreading.cs @@ -9,7 +9,7 @@ using static Avalonia.X11.XLib; namespace Avalonia.X11 { - internal unsafe class X11PlatformThreading : IPlatformThreadingInterface + internal unsafe class X11PlatformThreading : IControlledDispatcherImpl, IDispatcherClock { private readonly AvaloniaX11Platform _platform; private readonly IntPtr _display; @@ -68,44 +68,11 @@ namespace Avalonia.X11 private int _sigread, _sigwrite; private object _lock = new object(); private bool _signaled; - private DispatcherPriority _signaledPriority; + private bool _wakeupRequested; + private long? _nextTimer; private int _epoll; private Stopwatch _clock = Stopwatch.StartNew(); - private class X11Timer : IDisposable - { - private readonly X11PlatformThreading _parent; - - public X11Timer(X11PlatformThreading parent, DispatcherPriority prio, TimeSpan interval, Action tick) - { - _parent = parent; - Priority = prio; - Tick = tick; - Interval = interval; - Reschedule(); - } - - public DispatcherPriority Priority { get; } - public TimeSpan NextTick { get; private set; } - public TimeSpan Interval { get; } - public Action Tick { get; } - public bool Disposed { get; private set; } - - public void Reschedule() - { - NextTick = _parent._clock.Elapsed + Interval; - } - - public void Dispose() - { - Disposed = true; - lock (_parent._lock) - _parent._timers.Remove(this); - } - } - - private List _timers = new List(); - public X11PlatformThreading(AvaloniaX11Platform platform) { _platform = platform; @@ -139,29 +106,16 @@ namespace Avalonia.X11 throw new X11Exception("Unable to attach signal pipe to epoll"); } - private int TimerComparer(X11Timer t1, X11Timer t2) - { - return t2.Priority - t1.Priority; - } - private void CheckSignaled() { - int buf = 0; - while (read(_sigread, &buf, new IntPtr(4)).ToInt64() > 0) - { - } - - DispatcherPriority prio; lock (_lock) { if (!_signaled) return; _signaled = false; - prio = _signaledPriority; - _signaledPriority = DispatcherPriority.MinValue; } - Signaled?.Invoke(prio); + Signaled?.Invoke(); } private unsafe void HandleX11(CancellationToken cancellationToken) @@ -170,6 +124,7 @@ namespace Avalonia.X11 { if (cancellationToken.IsCancellationRequested) return; + XNextEvent(_display, out var xev); if(XFilterEvent(ref xev, IntPtr.Zero)) continue; @@ -195,90 +150,94 @@ namespace Avalonia.X11 XFreeEventData(_display, &xev.GenericEventCookie); } } - - Dispatcher.UIThread.RunJobs(); } - + public void RunLoop(CancellationToken cancellationToken) { - var readyTimers = new List(); while (!cancellationToken.IsCancellationRequested) { - var now = _clock.Elapsed; - TimeSpan? nextTick = null; - readyTimers.Clear(); - lock(_timers) - foreach (var t in _timers) - { - if (nextTick == null || t.NextTick < nextTick.Value) - nextTick = t.NextTick; - if (t.NextTick < now) - readyTimers.Add(t); - } - - readyTimers.Sort(TimerComparer); - - foreach (var t in readyTimers) + var now = _clock.ElapsedMilliseconds; + if (_nextTimer.HasValue && now > _nextTimer.Value) { - if (cancellationToken.IsCancellationRequested) - return; - t.Tick(); - if(!t.Disposed) - { - t.Reschedule(); - if (nextTick == null || t.NextTick < nextTick.Value) - nextTick = t.NextTick; - } + Timer?.Invoke(); } if (cancellationToken.IsCancellationRequested) return; + //Flush whatever requests were made to XServer XFlush(_display); epoll_event ev; if (XPending(_display) == 0) - epoll_wait(_epoll, &ev, 1, - nextTick == null ? -1 : Math.Max(1, (int)(nextTick.Value - _clock.Elapsed).TotalMilliseconds)); + { + now = _clock.ElapsedMilliseconds; + if (_nextTimer < now) + continue; + + var timeout = _nextTimer == null ? (int)-1 : Math.Max(1, _nextTimer.Value - now); + epoll_wait(_epoll, &ev, 1, (int)Math.Min(int.MaxValue, timeout)); + + // Drain the signaled pipe + int buf = 0; + while (read(_sigread, &buf, new IntPtr(4)).ToInt64() > 0) + { + } + + lock (_lock) + _wakeupRequested = false; + } + if (cancellationToken.IsCancellationRequested) return; CheckSignaled(); HandleX11(cancellationToken); + while (_platform.EventGrouperDispatchQueue.HasJobs) + { + CheckSignaled(); + _platform.EventGrouperDispatchQueue.DispatchNext(); + } } } - + private void Wakeup() + { + lock (_lock) + { + if(_wakeupRequested) + return; + _wakeupRequested = true; + int buf = 0; + write(_sigwrite, &buf, new IntPtr(1)); + } + } - public void Signal(DispatcherPriority priority) + public void Signal() { lock (_lock) { - if (priority > _signaledPriority) - _signaledPriority = priority; - if(_signaled) return; _signaled = true; - int buf = 0; - write(_sigwrite, &buf, new IntPtr(1)); + Wakeup(); } } public bool CurrentThreadIsLoopThread => Thread.CurrentThread == _mainThread; - public event Action Signaled; - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) + public event Action Signaled; + public event Action Timer; + + public void UpdateTimer(int? dueTimeInTicks) { - if (_mainThread != Thread.CurrentThread) - throw new InvalidOperationException("StartTimer can be only called from UI thread"); - if (interval <= TimeSpan.Zero) - throw new ArgumentException("Interval must be positive", nameof(interval)); - - // We assume that we are on the main thread and outside of epoll_wait, so there is no need for wakeup signal - - var timer = new X11Timer(this, priority, interval, tick); - lock(_timers) - _timers.Add(timer); - return timer; + _nextTimer = dueTimeInTicks; + if (_nextTimer != null) + Wakeup(); } + + + public int TickCount => (int)_clock.ElapsedMilliseconds; + public bool CanQueryPendingInput => true; + + public bool HasPendingInput => _platform.EventGrouperDispatchQueue.HasJobs || XPending(_display) != 0; } } diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs index 6634ab4d7b..5fde749099 100644 --- a/src/Avalonia.X11/X11Window.cs +++ b/src/Avalonia.X11/X11Window.cs @@ -187,7 +187,7 @@ namespace Avalonia.X11 UpdateMotifHints(); UpdateSizeHints(null); - _rawEventGrouper = new RawEventGrouper(DispatchInput); + _rawEventGrouper = new RawEventGrouper(DispatchInput, platform.EventGrouperDispatchQueue); _transparencyHelper = new TransparencyHelper(_x11, _handle, platform.Globals); _transparencyHelper.SetTransparencyRequest(WindowTransparencyLevel.None); @@ -507,7 +507,6 @@ namespace Avalonia.X11 if (changedSize && !updatedSizeViaScaling && !_popup) Resized?.Invoke(ClientSize, PlatformResizeReason.Unspecified); - Dispatcher.UIThread.RunJobs(DispatcherPriority.Layout); }, DispatcherPriority.Layout); if (_useRenderWindow) XConfigureResizeWindow(_x11.Display, _renderHandle, ev.ConfigureEvent.width, diff --git a/src/Shared/RawEventGrouping.cs b/src/Shared/RawEventGrouping.cs index c4772db820..66b24e9722 100644 --- a/src/Shared/RawEventGrouping.cs +++ b/src/Shared/RawEventGrouping.cs @@ -12,28 +12,47 @@ namespace Avalonia; While doing that it groups Move and TouchUpdate events so we could provide GetIntermediatePoints API */ -internal class RawEventGrouper : IDisposable +internal interface IRawEventGrouperDispatchQueue { - private readonly Action _eventCallback; - private readonly Queue _inputQueue = new(); + void Add(RawInputEventArgs args, Action handler); +} + + +class ManualRawEventGrouperDispatchQueue : IRawEventGrouperDispatchQueue +{ + private readonly Queue<(RawInputEventArgs args, Action handler)> _inputQueue = new(); + public void Add(RawInputEventArgs args, Action handler) => _inputQueue.Enqueue((args, handler)); + + public bool HasJobs => _inputQueue.Count > 0; + + public void DispatchNext() + { + if (_inputQueue.Count == 0) + return; + var ev = _inputQueue.Dequeue(); + ev.handler(ev.args); + } +} + +internal class AutomaticRawEventGrouperDispatchQueue : IRawEventGrouperDispatchQueue +{ + private readonly Queue<(RawInputEventArgs args, Action handler)> _inputQueue = new(); private readonly Action _dispatchFromQueue; - private readonly Dictionary _lastTouchPoints = new(); - private RawInputEventArgs? _lastEvent; - public RawEventGrouper(Action eventCallback) + public AutomaticRawEventGrouperDispatchQueue() { - _eventCallback = eventCallback; _dispatchFromQueue = DispatchFromQueue; } - private void AddToQueue(RawInputEventArgs args) + public void Add(RawInputEventArgs args, Action handler) { - _lastEvent = args; - _inputQueue.Enqueue(args); + _inputQueue.Enqueue((args, handler)); + if (_inputQueue.Count == 1) Dispatcher.UIThread.Post(_dispatchFromQueue, DispatcherPriority.Input); + } - + private void DispatchFromQueue() { while (true) @@ -43,17 +62,8 @@ internal class RawEventGrouper : IDisposable var ev = _inputQueue.Dequeue(); - if (_lastEvent == ev) - _lastEvent = null; + ev.handler(ev.args); - if (ev is RawTouchEventArgs { Type: RawPointerEventType.TouchUpdate } touchUpdate) - _lastTouchPoints.Remove(touchUpdate.RawPointerId); - - _eventCallback?.Invoke(ev); - - if (ev is RawPointerEventArgs { IntermediatePoints.Value: PooledList list }) - list.Dispose(); - if (Dispatcher.UIThread.HasJobsWithPriority(DispatcherPriority.Input + 1)) { Dispatcher.UIThread.Post(_dispatchFromQueue, DispatcherPriority.Input); @@ -61,6 +71,47 @@ internal class RawEventGrouper : IDisposable } } } +} + +internal class RawEventGrouper : IDisposable +{ + private readonly Action _eventCallback; + private readonly IRawEventGrouperDispatchQueue _queue; + private readonly Dictionary _lastTouchPoints = new(); + private RawInputEventArgs? _lastEvent; + private Action _dispatch; + private bool _disposed; + + public RawEventGrouper(Action eventCallback, IRawEventGrouperDispatchQueue? queue = null) + { + _eventCallback = eventCallback; + _queue = queue ?? new AutomaticRawEventGrouperDispatchQueue(); + _dispatch = Dispatch; + } + + private void AddToQueue(RawInputEventArgs args) + { + _lastEvent = args; + _queue.Add(args, _dispatch); + } + + private void Dispatch(RawInputEventArgs ev) + { + if (!_disposed) + { + if (_lastEvent == ev) + _lastEvent = null; + + if (ev is RawTouchEventArgs { Type: RawPointerEventType.TouchUpdate } touchUpdate) + _lastTouchPoints.Remove(touchUpdate.RawPointerId); + + _eventCallback?.Invoke(ev); + } + + if (ev is RawPointerEventArgs { IntermediatePoints.Value: PooledList list }) + list.Dispose(); + } + public void HandleEvent(RawInputEventArgs args) { @@ -123,7 +174,7 @@ internal class RawEventGrouper : IDisposable public void Dispose() { - _inputQueue.Clear(); + _disposed = true; _lastEvent = null; _lastTouchPoints.Clear(); } diff --git a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs index 1dd2ef20c7..9618a5b4cd 100644 --- a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs +++ b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs @@ -1784,6 +1784,49 @@ namespace Avalonia.Win32.Interop return result; } + [Flags] + internal enum QueueStatusFlags + { + QS_KEY = 0x0001, + QS_MOUSEMOVE = 0x0002, + QS_MOUSEBUTTON = 0x0004, + QS_POSTMESSAGE = 0x0008, + QS_TIMER = 0x0010, + QS_PAINT = 0x0020, + QS_SENDMESSAGE = 0x0040, + QS_HOTKEY = 0x0080, + QS_ALLPOSTMESSAGE = 0x0100, + QS_EVENT = 0x0200, + QS_MOUSE = QS_MOUSEMOVE | QS_MOUSEBUTTON, + QS_INPUT = QS_MOUSE | QS_KEY, + QS_ALLEVENTS = QS_INPUT | QS_POSTMESSAGE | QS_TIMER | QS_PAINT | QS_HOTKEY, + QS_ALLINPUT = QS_INPUT | QS_POSTMESSAGE | QS_TIMER | QS_PAINT | QS_HOTKEY | QS_SENDMESSAGE + } + + [Flags] + internal enum MsgWaitForMultipleObjectsFlags + { + MWMO_WAITALL = 0x0001, + MWMO_ALERTABLE = 0x0002, + MWMO_INPUTAVAILABLE = 0x0004 + } + + [DllImport("user32", EntryPoint="MsgWaitForMultipleObjectsEx", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)] + private static extern int IntMsgWaitForMultipleObjectsEx(int nCount, IntPtr[]? pHandles, int dwMilliseconds, + QueueStatusFlags dwWakeMask, MsgWaitForMultipleObjectsFlags dwFlags); + + internal static int MsgWaitForMultipleObjectsEx(int nCount, IntPtr[]? pHandles, int dwMilliseconds, + QueueStatusFlags dwWakeMask, MsgWaitForMultipleObjectsFlags dwFlags) + { + int result = IntMsgWaitForMultipleObjectsEx(nCount, pHandles, dwMilliseconds, dwWakeMask, dwFlags); + if(result == -1) + { + throw new Win32Exception(); + } + + return result; + } + [DllImport("user32.dll")] internal static extern int SetWindowCompositionAttribute(IntPtr hwnd, ref WindowCompositionAttributeData data); diff --git a/src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs b/src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs new file mode 100644 index 0000000000..0916490ed8 --- /dev/null +++ b/src/Windows/Avalonia.Win32/Win32DispatcherImpl.cs @@ -0,0 +1,121 @@ +using System; +using System.Runtime.InteropServices; +using System.Threading; +using Avalonia.Threading; +using Avalonia.Win32.Interop; +using static Avalonia.Win32.Interop.UnmanagedMethods; +namespace Avalonia.Win32; + +internal class Win32DispatcherImpl : IControlledDispatcherImpl, IDispatcherClock +{ + private readonly IntPtr _messageWindow; + private static Thread? s_uiThread; + private IntPtr? _timerHandle; + private readonly TimerProc _timerDelegate; + public Win32DispatcherImpl(IntPtr messageWindow) + { + _messageWindow = messageWindow; + s_uiThread = Thread.CurrentThread; + _timerDelegate = TimerProc; + } + + public bool CurrentThreadIsLoopThread => s_uiThread == Thread.CurrentThread; + internal const int SignalW = unchecked((int)0xdeadbeaf); + internal const int SignalL = unchecked((int)0x12345678); + + public void Signal() => + // Messages from PostMessage are always processed before any user input, + // so Win32 should call us ASAP + PostMessage( + _messageWindow, + (int)WindowsMessage.WM_DISPATCH_WORK_ITEM, + new IntPtr(SignalW), + new IntPtr(SignalL)); + + public void DispatchWorkItem() => Signaled?.Invoke(); + + public event Action? Signaled; + public event Action? Timer; + + void TimerProc(IntPtr hWnd, uint uMsg, IntPtr nIdEvent, uint dwTime) => Timer?.Invoke(); + + public void UpdateTimer(int? dueTimeInTicks) + { + if (_timerHandle.HasValue) + KillTimer(IntPtr.Zero, _timerHandle.Value); + if (dueTimeInTicks == null) + return; + + var interval = (uint)Math.Max(1, TickCount - dueTimeInTicks.Value); + + _timerHandle = SetTimer( + IntPtr.Zero, + IntPtr.Zero, + interval, + _timerDelegate); + } + + public bool CanQueryPendingInput => true; + + public bool HasPendingInput + { + get + { + // We need to know if there is any pending input in the Win32 + // queue because we want to only process Avalon "background" + // items after Win32 input has been processed. + // + // Win32 provides the GetQueueStatus API -- but it has a major + // drawback: it only counts "new" input. This means that + // sometimes it could return false, even if there really is input + // that needs to be processed. This results in very hard to + // find bugs. + // + // Luckily, Win32 also provides the MsgWaitForMultipleObjectsEx + // API. While more awkward to use, this API can return queue + // status information even if the input is "old". The various + // flags we use are: + // + // QS_INPUT + // This represents any pending input - such as mouse moves, or + // key presses. It also includes the new GenericInput messages. + // + // QS_EVENT + // This is actually a private flag that represents the various + // events that can be queued in Win32. Some of these events + // can cause input, but Win32 doesn't include them in the + // QS_INPUT flag. An example is WM_MOUSELEAVE. + // + // QS_POSTMESSAGE + // If there is already a message in the queue, we need to process + // it before we can process input. + // + // MWMO_INPUTAVAILABLE + // This flag indicates that any input (new or old) is to be + // reported. + // + + return MsgWaitForMultipleObjectsEx(0, null, 0, + QueueStatusFlags.QS_INPUT | QueueStatusFlags.QS_EVENT | QueueStatusFlags.QS_POSTMESSAGE, + MsgWaitForMultipleObjectsFlags.MWMO_INPUTAVAILABLE) == 0; + } + } + + public void RunLoop(CancellationToken cancellationToken) + { + var result = 0; + while (!cancellationToken.IsCancellationRequested + && (result = GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0) + { + TranslateMessage(ref msg); + DispatchMessage(ref msg); + } + if (result < 0) + { + Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform) + ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(RunLoop), Marshal.GetLastWin32Error()); + } + } + + public int TickCount => Environment.TickCount; +} diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs index 7a9f2bb814..6a5841f36f 100644 --- a/src/Windows/Avalonia.Win32/Win32Platform.cs +++ b/src/Windows/Avalonia.Win32/Win32Platform.cs @@ -107,21 +107,21 @@ namespace Avalonia namespace Avalonia.Win32 { - internal class Win32Platform : IPlatformThreadingInterface, IWindowingPlatform, IPlatformIconLoader, IPlatformLifetimeEventsImpl + internal class Win32Platform : IWindowingPlatform, IPlatformIconLoader, IPlatformLifetimeEventsImpl { private static readonly Win32Platform s_instance = new(); - private static Thread? s_uiThread; private static Win32PlatformOptions? s_options; private static Compositor? s_compositor; private WndProc? _wndProcDelegate; private IntPtr _hwnd; - private readonly List _delegates = new(); + private Win32DispatcherImpl _dispatcher; public Win32Platform() { SetDpiAwareness(); CreateMessageWindow(); + _dispatcher = new Win32DispatcherImpl(_hwnd); } internal static Win32Platform Instance => s_instance; @@ -157,7 +157,7 @@ namespace Avalonia.Win32 .Bind().ToConstant(CursorFactory.Instance) .Bind().ToConstant(WindowsKeyboardDevice.Instance) .Bind().ToSingleton() - .Bind().ToConstant(s_instance) + .Bind().ToConstant(s_instance._dispatcher) .Bind().ToConstant(new RenderLoop()) .Bind().ToConstant(renderTimer) .Bind().ToConstant(s_instance) @@ -174,8 +174,6 @@ namespace Avalonia.Win32 .Bind().ToConstant(new WindowsMountedVolumeInfoProvider()) .Bind().ToConstant(s_instance); - s_uiThread = Thread.CurrentThread; - var platformGraphics = options.CustomPlatformGraphics ?? Win32GlManager.Initialize(); @@ -205,67 +203,15 @@ namespace Avalonia.Win32 } } - public void RunLoop(CancellationToken cancellationToken) - { - var result = 0; - while (!cancellationToken.IsCancellationRequested - && (result = GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0) - { - TranslateMessage(ref msg); - DispatchMessage(ref msg); - } - if (result < 0) - { - Logging.Logger.TryGet(Logging.LogEventLevel.Error, Logging.LogArea.Win32Platform) - ?.Log(this, "Unmanaged error in {0}. Error Code: {1}", nameof(RunLoop), Marshal.GetLastWin32Error()); - } - } - - public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action callback) - { - TimerProc timerDelegate = (_, _, _, _) => callback(); - - IntPtr handle = SetTimer( - IntPtr.Zero, - IntPtr.Zero, - (uint)interval.TotalMilliseconds, - timerDelegate); - - // Prevent timerDelegate being garbage collected. - _delegates.Add(timerDelegate); - - return Disposable.Create(() => - { - _delegates.Remove(timerDelegate); - KillTimer(IntPtr.Zero, handle); - }); - } - - private const int SignalW = unchecked((int)0xdeadbeaf); - private const int SignalL = unchecked((int)0x12345678); - - public void Signal(DispatcherPriority prio) - { - PostMessage( - _hwnd, - (int)WindowsMessage.WM_DISPATCH_WORK_ITEM, - new IntPtr(SignalW), - new IntPtr(SignalL)); - } - - public bool CurrentThreadIsLoopThread => s_uiThread == Thread.CurrentThread; - - public event Action? Signaled; - public event EventHandler? ShutdownRequested; [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Using Win32 naming for consistency.")] private IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) { - if (msg == (int)WindowsMessage.WM_DISPATCH_WORK_ITEM && wParam.ToInt64() == SignalW && lParam.ToInt64() == SignalL) - { - Signaled?.Invoke(null); - } + if (msg == (int)WindowsMessage.WM_DISPATCH_WORK_ITEM + && wParam.ToInt64() == Win32DispatcherImpl.SignalW + && lParam.ToInt64() == Win32DispatcherImpl.SignalL) + _dispatcher?.DispatchWorkItem(); if(msg == (uint)WindowsMessage.WM_QUERYENDSESSION) { diff --git a/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs b/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs index 41c0eb3958..510d7c2c6d 100644 --- a/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs +++ b/tests/Avalonia.Base.UnitTests/Composition/CompositionAnimationTests.cs @@ -62,13 +62,24 @@ public class CompositionAnimationTests } } } + + class DummyDispatcher : IDispatcher + { + public bool CheckAccess() => true; + + public void VerifyAccess() + { + } + + public void Post(Action action, DispatcherPriority priority = default) => throw new NotSupportedException(); + } [AnimationDataProvider] [Theory] public void GenericCheck(AnimationData data) { var compositor = - new Compositor(new RenderLoop(new CompositorTestServices.ManualRenderTimer(), new Dispatcher(null)), null); + new Compositor(new RenderLoop(new CompositorTestServices.ManualRenderTimer(), new DummyDispatcher()), null); var target = compositor.CreateSolidColorVisual(); var ani = new ScalarKeyFrameAnimation(null); foreach (var frame in data.Frames) diff --git a/tests/Avalonia.Base.UnitTests/DispatcherTests.cs b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs new file mode 100644 index 0000000000..450c857cfe --- /dev/null +++ b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs @@ -0,0 +1,180 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Avalonia.Threading; +using Xunit; +namespace Avalonia.Base.UnitTests; + +public class DispatcherTests +{ + class SimpleDispatcherImpl : IDispatcherImpl, IDispatcherClock, IDispatcherImplWithPendingInput + { + public bool CurrentThreadIsLoopThread => true; + + public void Signal() => AskedForSignal = true; + + public event Action Signaled; + public event Action Timer; + public int? NextTimer { get; private set; } + public bool AskedForSignal { get; private set; } + + public void UpdateTimer(int? dueTimeInTicks) + { + NextTimer = dueTimeInTicks; + } + + public int TickCount { get; set; } + + public void ExecuteSignal() + { + if (!AskedForSignal) + return; + AskedForSignal = false; + Signaled?.Invoke(); + } + + public void ExecuteTimer() + { + if (NextTimer == null) + return; + TickCount = NextTimer.Value; + Timer?.Invoke(); + } + + public bool CanQueryPendingInput => TestInputPending != null; + public bool HasPendingInput => TestInputPending == true; + public bool? TestInputPending { get; set; } + } + + + [Fact] + public void DispatcherExecutesJobsAccordingToPriority() + { + var impl = new SimpleDispatcherImpl(); + var disp = new Dispatcher(impl, impl); + var actions = new List(); + disp.Post(()=>actions.Add("Background"), DispatcherPriority.Background); + disp.Post(()=>actions.Add("Render"), DispatcherPriority.Render); + disp.Post(()=>actions.Add("Input"), DispatcherPriority.Input); + Assert.True(impl.AskedForSignal); + impl.ExecuteSignal(); + Assert.Equal(new[] { "Render", "Input", "Background" }, actions); + } + + [Fact] + public void DispatcherPreservesOrderWhenChangingPriority() + { + var impl = new SimpleDispatcherImpl(); + var disp = new Dispatcher(impl, impl); + var actions = new List(); + var toPromote = disp.InvokeAsync(()=>actions.Add("PromotedRender"), DispatcherPriority.Background); + var toPromote2 = disp.InvokeAsync(()=>actions.Add("PromotedRender2"), DispatcherPriority.Input); + disp.Post(() => actions.Add("Render"), DispatcherPriority.Render); + + toPromote.Priority = DispatcherPriority.Render; + toPromote2.Priority = DispatcherPriority.Render; + + Assert.True(impl.AskedForSignal); + impl.ExecuteSignal(); + + Assert.Equal(new[] { "PromotedRender", "PromotedRender2", "Render" }, actions); + } + + [Fact] + public void DispatcherStopsItemProcessingWhenInteractivityDeadlineIsReached() + { + var impl = new SimpleDispatcherImpl(); + var disp = new Dispatcher(impl, impl); + var actions = new List(); + for (var c = 0; c < 10; c++) + { + var itemId = c; + disp.Post(() => + { + actions.Add(itemId); + impl.TickCount += 20; + }, DispatcherPriority.Background); + } + + Assert.False(impl.AskedForSignal); + Assert.NotNull(impl.NextTimer); + + impl.ExecuteTimer(); + Assert.True(impl.AskedForSignal); + Assert.Null(impl.NextTimer); + + for (var c = 0; c < 4; c++) + { + if (impl.NextTimer != null) + impl.ExecuteTimer(); + Assert.True(impl.AskedForSignal); + impl.ExecuteSignal(); + var expectedCount = (c + 1) * 3; + if (c == 3) + expectedCount = 10; + + Assert.Equal(Enumerable.Range(0, expectedCount), actions); + Assert.False(impl.AskedForSignal); + if (c < 3) + { + Assert.True(impl.NextTimer > impl.TickCount); + } + else + Assert.Null(impl.NextTimer); + } + } + + + [Fact] + public void DispatcherStopsItemProcessingWhenInputIsPending() + { + var impl = new SimpleDispatcherImpl(); + impl.TestInputPending = false; + var disp = new Dispatcher(impl, impl); + var actions = new List(); + for (var c = 0; c < 10; c++) + { + var itemId = c; + disp.Post(() => + { + actions.Add(itemId); + if (itemId == 0 || itemId == 3 || itemId == 7) + impl.TestInputPending = true; + }, DispatcherPriority.Background); + } + Assert.False(impl.AskedForSignal); + Assert.NotNull(impl.NextTimer); + + impl.ExecuteTimer(); + Assert.True(impl.AskedForSignal); + Assert.Null(impl.NextTimer); + + for (var c = 0; c < 4; c++) + { + if (impl.NextTimer != null) + impl.ExecuteTimer(); + Assert.True(impl.AskedForSignal); + impl.ExecuteSignal(); + var expectedCount = c switch + { + 0 => 1, + 1 => 4, + 2 => 8, + 3 => 10 + }; + + Assert.Equal(Enumerable.Range(0, expectedCount), actions); + Assert.False(impl.AskedForSignal); + if (c < 3) + { + Assert.True(impl.NextTimer > impl.TickCount); + impl.TickCount = impl.NextTimer.Value + 1; + } + else + Assert.Null(impl.NextTimer); + + impl.TestInputPending = false; + } + } + +} \ No newline at end of file diff --git a/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs index 6855a378b4..97740fab00 100644 --- a/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs +++ b/tests/Avalonia.Base.UnitTests/Rendering/RenderLoopTests.cs @@ -47,9 +47,8 @@ namespace Avalonia.Base.UnitTests.Rendering { var dispatcher = new Mock(); dispatcher.Setup( - d => d.InvokeAsync(It.IsAny(), DispatcherPriority.Render)) - .Callback((Action a, DispatcherPriority _) => a()) - .Returns(Task.CompletedTask); + d => d.Post(It.IsAny(), DispatcherPriority.Render)) + .Callback((Action a, DispatcherPriority _) => a()); var timer = new Mock(); var loop = new RenderLoop(timer.Object, dispatcher.Object); diff --git a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs index c196a8f984..c268fed28c 100644 --- a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs +++ b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs @@ -157,7 +157,7 @@ namespace Avalonia.Controls.UnitTests } } - [Fact] + [Fact(Skip = "Timers should NOT, in fact, be checked via IPlatformThreadingInterface")] public void Should_Open_On_Pointer_Enter_With_Delay() { Action timercallback = null; diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs index 933958b3a0..3aeb27dd50 100644 --- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs +++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; +using System.Runtime.CompilerServices; using System.Xml; using Avalonia.Controls; using Avalonia.Markup.Xaml.Styling; diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs b/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs index ea03b003ca..6d26de2b29 100644 --- a/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs +++ b/tests/Avalonia.Markup.Xaml.UnitTests/XamlTestBase.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.IO; using System.Reflection; using System.Text; +using Avalonia.Controls; using Avalonia.Data; namespace Avalonia.Markup.Xaml.UnitTests @@ -13,6 +14,7 @@ namespace Avalonia.Markup.Xaml.UnitTests { // Ensure necessary assemblies are loaded. var _ = typeof(TemplateBinding); + GC.KeepAlive(typeof(ItemsRepeater)); if (AvaloniaLocator.Current.GetService() == null) AvaloniaLocator.CurrentMutable.Bind() .ToConstant(new TestXamlLoaderShim()); diff --git a/tests/Avalonia.UnitTests/UnitTestApplication.cs b/tests/Avalonia.UnitTests/UnitTestApplication.cs index fe7f9712b4..3108e09315 100644 --- a/tests/Avalonia.UnitTests/UnitTestApplication.cs +++ b/tests/Avalonia.UnitTests/UnitTestApplication.cs @@ -43,7 +43,7 @@ namespace Avalonia.UnitTests { var scope = AvaloniaLocator.EnterScope(); var app = new UnitTestApplication(services); - Dispatcher.UIThread.UpdateServices(); + Dispatcher.ResetForUnitTests(); return Disposable.Create(() => { if (Dispatcher.UIThread.CheckAccess()) @@ -52,7 +52,7 @@ namespace Avalonia.UnitTests } scope.Dispose(); - Dispatcher.UIThread.UpdateServices(); + Dispatcher.ResetForUnitTests(); }); }