Fix input starvation issues on resource-constrained devices.

[grokys]

What does the pull request do?

On resource-constrained devices, input starvation can occur more commonly than on a typical desktop device, and when it happens it's important that the device retains some semblance of interactivity. This PR makes two small tweaks which improve this situation:

• Reduces the input starvation timeout from 1 second to 0.2 seconds, so that input is processed at least 5 times per second
• Ensures that the input starvation code is run from ICompositorScheduler.CommitRequested by passing false for the now parameter to ScheduleRender

[kekekeks]

We should probably make it configurable, otherwise we'll risk running into issues with XPF too.

[grokys]

Any preference as to where this configuration should be placed?

[kekekeks]

We probably need a separate options class. DispatcherOptions, maybe?

We should also consider runtimeconfig.json-based settings at some point.

[grokys]

Done. Please check that the naming and doc comments are to your liking.

[avaloniaui-bot]

You can test this PR using the following package version. 11.2.999-cibuild0046640-alpha. (feed url: https://nuget-feed-all.avaloniaui.net/v3/index.json) [PRBUILDID]

[maxkatz6]

We usually keep other **Options classes in Avalonia namespace.
SkiaOptions as an example: https://github.com/AvaloniaUI/Avalonia/blob/master/src/Skia/Avalonia.Skia/SkiaOptions.cs#L4

So it won't require any extra usings for app builder.

[grokys]

We don't really seem to be consistent in this. A couple of exceptions I've seen are:

• Avalonia.Rendering.Composition.CompositionOptions
• Avalonia.LinuxFramebuffer.LinuxFramebufferPlatformOptions

However, yes I can move this class to the root namespace.

[workgroupengineering]

Suggested change

	public class DispatcherOptions
	public record DispatcherOptions

[grokys]

Why do we need a record here? AFAICS we don't need any record features and using a record will bloat the size of the code:

[NullableContext(1)]
    [Nullable(0)]
    public class DispatcherOptions : IEquatable<DispatcherOptions>
    {
        [CompilerGenerated]
        private TimeSpan <InputStarvationTimeout>k__BackingField;

        [CompilerGenerated]
        protected virtual Type EqualityContract
        {
            [CompilerGenerated]
            get
            {
                return typeof(DispatcherOptions);
            }
        }

        public TimeSpan InputStarvationTimeout
        {
            [CompilerGenerated]
            get
            {
                return <InputStarvationTimeout>k__BackingField;
            }
            [CompilerGenerated]
            set
            {
                <InputStarvationTimeout>k__BackingField = value;
            }
        }

        [CompilerGenerated]
        public override string ToString()
        {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.Append("DispatcherOptions");
            stringBuilder.Append(" { ");
            if (PrintMembers(stringBuilder))
            {
                stringBuilder.Append(' ');
            }
            stringBuilder.Append('}');
            return stringBuilder.ToString();
        }

        [CompilerGenerated]
        protected virtual bool PrintMembers(StringBuilder builder)
        {
            RuntimeHelpers.EnsureSufficientExecutionStack();
            builder.Append("InputStarvationTimeout = ");
            builder.Append(InputStarvationTimeout.ToString());
            return true;
        }

        [NullableContext(2)]
        [CompilerGenerated]
        public static bool operator !=(DispatcherOptions left, DispatcherOptions right)
        {
            return !(left == right);
        }

        [NullableContext(2)]
        [CompilerGenerated]
        public static bool operator ==(DispatcherOptions left, DispatcherOptions right)
        {
            if ((object)left != right)
            {
                if ((object)left != null)
                {
                    return left.Equals(right);
                }
                return false;
            }
            return true;
        }

        [CompilerGenerated]
        public override int GetHashCode()
        {
            return EqualityComparer<Type>.Default.GetHashCode(EqualityContract) * -1521134295 + EqualityComparer<TimeSpan>.Default.GetHashCode(<InputStarvationTimeout>k__BackingField);
        }

        [NullableContext(2)]
        [CompilerGenerated]
        public override bool Equals(object obj)
        {
            return Equals(obj as DispatcherOptions);
        }

        [NullableContext(2)]
        [CompilerGenerated]
        public virtual bool Equals(DispatcherOptions other)
        {
            if ((object)this != other)
            {
                if ((object)other != null && EqualityContract == other.EqualityContract)
                {
                    return EqualityComparer<TimeSpan>.Default.Equals(<InputStarvationTimeout>k__BackingField, other.<InputStarvationTimeout>k__BackingField);
                }
                return false;
            }
            return true;
        }

        [CompilerGenerated]
        public virtual DispatcherOptions <Clone>$()
        {
            return new DispatcherOptions(this);
        }

        [CompilerGenerated]
        protected DispatcherOptions(DispatcherOptions original)
        {
            <InputStarvationTimeout>k__BackingField = original.<InputStarvationTimeout>k__BackingField;
        }

        public DispatcherOptions()
        {
            <InputStarvationTimeout>k__BackingField = TimeSpan.FromSeconds(1.0);
            base..ctor();
        }
    }

[workgroupengineering]

Suggested change

	public TimeSpan InputStarvationTimeout { get; set; } = TimeSpan.FromSeconds(1);
	public TimeSpan InputStarvationTimeout { get; init; } = TimeSpan.FromSeconds(1);

[grokys]

None of our other *Options classes uses init (because they predate init properties). Not sure if it's better to make new options properties init-only and leave the others, or convert them all for 12.0. Not very important IMO though in the sense that init won't solve any real-world problem here.

[Gillibald]

As long as these options are only read once by the backend during initialization they can be mutable.

[avaloniaui-bot]

You can test this PR using the following package version. 11.2.999-cibuild0046706-alpha. (feed url: https://nuget-feed-all.avaloniaui.net/v3/index.json) [PRBUILDID]