ObservableTaskCommand.cs

using System;
using System.ComponentModel;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.Input;
 
namespace NeuroAccessMaui.UI.MVVM
{
    [Flags]
    public enum ObservableTaskCommandOptions
    {
        None = 0,
        AllowConcurrentRestart = 1 << 0,
    }
 
    public class ObservableTaskCommand<TProgress> : IAsyncRelayCommand
    {
        private readonly Func<TaskContext<TProgress>, Task> taskFactory;
        private readonly Func<bool>? canExecute;
        private readonly ObservableTaskCommandOptions options;
 
        public ObservableTask<TProgress> Notifier { get; }
 
        // Constructor without canExecute (defaults to always executable and no options)
        public ObservableTaskCommand(
            Func<TaskContext<TProgress>, Task> taskFactory)
             : this(taskFactory, null, ObservableTaskCommandOptions.None)
        {
        }
 
        // Constructor with optional canExecute and options
        public ObservableTaskCommand(
            Func<TaskContext<TProgress>, Task> taskFactory,
            Func<bool>? canExecute,
            ObservableTaskCommandOptions options = ObservableTaskCommandOptions.None)
        {
            this.taskFactory = taskFactory ?? throw new ArgumentNullException(nameof(taskFactory));
            this.canExecute = canExecute;
            this.options = options;
            this.Notifier = new ObservableTask<TProgress>();
            // Forward property changes from the notifier to this command.
            this.Notifier.PropertyChanged += (s, e) => this.PropertyChanged?.Invoke(this, e);
        }
 
        public async Task ExecuteAsync()
        {
            if (!this.CanExecute(null))
                return;
 
            this.NotifyCanExecuteChanged();
 
            // Start the task via the notifier.
            this.Notifier.Load(ctx => this.taskFactory(ctx), this);
            Task? Task = this.Notifier.CurrentTask;
            if (Task is not null)
            {
                // When the task completes, raise CanExecuteChanged (on the UI thread).
                await Task.ContinueWith(
                     _ => this.NotifyCanExecuteChanged(),
                     TaskScheduler.FromCurrentSynchronizationContext());
                this.NotifyCanExecuteChanged();
            }
        }
 
        public Task ExecuteAsync(object? parameter) => this.ExecuteAsync();
 
        public bool CanExecute(object? parameter)
        {
            bool BaseCanExecute = this.canExecute?.Invoke() ?? true;
            if (!BaseCanExecute)
                return false;
 
            // If concurrent restarts are not allowed, return false if a task is running.
            if ((this.options & ObservableTaskCommandOptions.AllowConcurrentRestart) == 0)
            {
                if (this.Notifier.IsRunning)
                    return false;
            }
            return true;
        }
 
        public event EventHandler? CanExecuteChanged;
        public void NotifyCanExecuteChanged() => this.CanExecuteChanged?.Invoke(this, EventArgs.Empty);
 
        public void Execute(object? parameter) => _ = this.ExecuteAsync();
 
        public event PropertyChangedEventHandler? PropertyChanged;
 
        public void Cancel() => this.Notifier.Cancel();
 
        public Task? ExecutionTask => this.Notifier.CurrentTask;
 
        public bool CanBeCanceled =>
             this.Notifier.CancellationTokenSource is not null &&
             this.Notifier.CurrentTask is not null &&
             !this.Notifier.CurrentTask.IsCompleted;
 
        public bool IsCancellationRequested => this.Notifier.CancellationTokenSource?.IsCancellationRequested ?? false;
 
        public bool IsRunning => this.Notifier.CurrentTask is { IsCompleted: false };
    }
}