feat(ui): 完善 AnimationService

PCL.Core/UI/Animation/Animatable/ClrAnimatable.cs

@@ -24,4 +24,5 @@ public ClrAnimatable(
 
     object? IAnimatable.GetValue() => GetValue();
     void IAnimatable.SetValue(object? value) => SetValue((T)value!);
+    void IAnimatable.SetValue<TValue>(TValue value) => SetValue((T)(object)value!);
 }

PCL.Core/UI/Animation/Animatable/EmptyAnimatable.cs

@@ -0,0 +1,23 @@
+namespace PCL.Core.UI.Animation.Animatable;
+
+public sealed class EmptyAnimatable : IAnimatable
+{
+    public static EmptyAnimatable Instance { get; } = new();
+
+    private EmptyAnimatable() { }
+
+    public object? GetValue()
+    {
+        return null;
+    }
+
+    public void SetValue(object value)
+    {
+        // 空
+    }
+
+    public void SetValue<T>(T value)
+    {
+        // 空
+    }
+}

PCL.Core/UI/Animation/Animatable/IAnimatable.cs

@@ -4,4 +4,5 @@ public interface IAnimatable
 {
     public object? GetValue();
     public void SetValue(object value);
+    public void SetValue<T>(T value);
 }

PCL.Core/UI/Animation/Animatable/WpfAnimatable.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Windows;
+using System.Windows.Media;
 using PCL.Core.UI.Animation.ValueProcessor;
 
 namespace PCL.Core.UI.Animation.Animatable;
@@ -28,13 +30,76 @@ public sealed class WpfAnimatable(DependencyObject owner, DependencyProperty? pr
 
         ArgumentNullException.ThrowIfNull(actualProperty);
 
-        return Owner.GetValue(actualProperty);
+        var value  = Owner.GetValue(actualProperty);
+        return value switch
+        {
+            SolidColorBrush brush => (NColor)brush,
+            Color color => (NColor)color,
+            ScaleTransform scaleTransform => (NScaleTransform)scaleTransform,
+            RotateTransform rotateTransform => (NRotateTransform)rotateTransform,
+            _ => value
+        };
     }
 
     public void SetValue(object value)
     {
         value = ValueProcessorManager.Filter(value);
         ArgumentNullException.ThrowIfNull(Property);
+
+        value = value switch
+        {
+            NColor color => Property.Name switch
+            {
+                "Color" => (Color)color,
+                _ => (SolidColorBrush)color
+            },
+            NScaleTransform st => (ScaleTransform)st,
+            NRotateTransform rt => (RotateTransform)rt,
+            _ => value
+        };
+
         Owner.SetValue(Property, value);
     }
+
+    public void SetValue<T>(T value)
+    {
+        value = ValueProcessorManager.Filter(value);
+        ArgumentNullException.ThrowIfNull(Property);
+        SetValueCore(value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void SetValueCore<T>(T value)
+    {
+        ArgumentNullException.ThrowIfNull(Property);
+
+        if (typeof(T) == typeof(NColor))
+        {
+            var color = Unsafe.As<T, NColor>(ref value);
+
+            Owner.SetValue(
+                Property,
+                Property.Name == "Color"
+                    ? (Color)color
+                    : (SolidColorBrush)color);
+
+            return;
+        }
+
+        if (typeof(T) == typeof(NScaleTransform))
+        {
+            var st = Unsafe.As<T, NScaleTransform>(ref value);
+            Owner.SetValue(Property, (ScaleTransform)st);
+            return;
+        }
+
+        if (typeof(T) == typeof(NRotateTransform))
+        {
+            var rt = Unsafe.As<T, NRotateTransform>(ref value);
+            Owner.SetValue(Property, (RotateTransform)rt);
+            return;
+        }
+
+        Owner.SetValue(Property, value!);
+    }
 }

PCL.Core/UI/Animation/Core/ActionAnimation.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using PCL.Core.UI.Animation.Animatable;
+
+namespace PCL.Core.UI.Animation.Core;
+
+/// <summary>
+/// 用于在动画系统中执行 Action。
+/// </summary>
+public class ActionAnimation : AnimationBase
+{
+    public ActionAnimation() { }
+
+    public ActionAnimation(Action action) => Action = _ => action();
+
+    public ActionAnimation(Action<CancellationToken> action) => Action = action;
+
+    public Action<CancellationToken> Action { get; set; } = null!;
+    public override int CurrentFrame { get; set; }
+    public TimeSpan Delay { get; set; }
+
+    private CancellationTokenSource? _cts = new();
+    private TaskCompletionSource? _tcs;
+    private int _called = 0;
+
+    public override async Task<IAnimation> RunAsync(IAnimatable target)
+    {
+        ArgumentNullException.ThrowIfNull(Action);
+
+        _tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        _cts = new CancellationTokenSource();
+
+        var clone = (ActionAnimation)MemberwiseClone();
+        clone.Status = AnimationStatus.Running;
+
+        // 延迟
+        await Task.Delay(Delay);
+
+        Interlocked.Exchange(ref _called, 0);
+        _ = AnimationService.PushAnimationAsync(clone, target);
+        return await _tcs.Task.ContinueWith<IAnimation>(_ => clone);
+    }
+
+    public override IAnimation RunFireAndForget(IAnimatable target)
+    {
+        ArgumentNullException.ThrowIfNull(Action);
+
+        _cts = new CancellationTokenSource();
+
+        var clone = (ActionAnimation)MemberwiseClone();
+        clone.Status = AnimationStatus.Running;
+
+        _ = Task.Run(async () =>
+        {
+            // 延迟
+            await Task.Delay(Delay);
+
+            Interlocked.Exchange(ref _called, 0);
+            AnimationService.PushAnimationFireAndForget(clone, target);
+        });
+
+        return clone;
+    }
+
+    public override void Cancel()
+    {
+        Status = AnimationStatus.Canceled;
+        _cts?.Cancel();
+        _tcs?.TrySetCanceled();
+    }
+
+    public override IAnimationFrame? ComputeNextFrame(IAnimatable target)
+    {
+        if (Status is AnimationStatus.Canceled or AnimationStatus.Completed) return null;
+
+        if (Interlocked.CompareExchange(ref _called, 1, 0) == 0)
+        {
+            return new ActionAnimationFrame(() =>
+            {
+                Action(_cts!.Token);
+                Status = AnimationStatus.Completed;
+                _tcs?.TrySetResult();
+            });
+        }
+
+        return null;
+    }
+}

PCL.Core/UI/Animation/Core/ActionAnimationFrame.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace PCL.Core.UI.Animation.Core;
+
+public struct ActionAnimationFrame(Action action) : IAnimationFrame
+{
+    public Action Action { get; set; } = action;
+
+    public Action GetAction() => Action;
+}

PCL.Core/UI/Animation/Core/AnimationBase.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 using PCL.Core.UI.Animation.Animatable;
@@ -7,13 +8,18 @@ namespace PCL.Core.UI.Animation.Core;
 
 public abstract class AnimationBase : DependencyObject, IAnimation
 {
-    public abstract bool IsCompleted { get; }
+    public string Name { get; set; } = string.Empty;
+    private volatile int _status = (int)AnimationStatus.NotStarted;
+    public AnimationStatus Status
+    {
+        get => (AnimationStatus)_status;
+        internal set => Interlocked.Exchange(ref _status, (int)value);
+    }
     public abstract int CurrentFrame { get; set; }
 
-    public abstract Task RunAsync(IAnimatable target);
-    public abstract void RunFireAndForget(IAnimatable target);
+    public abstract Task<IAnimation> RunAsync(IAnimatable target);
+    public abstract IAnimation RunFireAndForget(IAnimatable target);
     public abstract void Cancel();
-
     public abstract IAnimationFrame? ComputeNextFrame(IAnimatable target);
 
     public void RaiseStarted() => Started?.Invoke(this, EventArgs.Empty);

PCL.Core/UI/Animation/Core/AnimationFrame.cs

@@ -5,12 +5,13 @@
 
 namespace PCL.Core.UI.Animation.Core;
 
-public readonly struct AnimationFrame<T> : IAnimationFrame where T : struct
-{
-    public IAnimatable Target { get; init; }
-    public T Value { get; init; }
-    public T StartValue { get; init; }
-    public T GetAbsoluteValue() => ValueProcessorManager.Add(StartValue, Value);
-
-    object IAnimationFrame.GetAbsoluteValue() => GetAbsoluteValue();
-}
+// public readonly struct AnimationFrame<T>(IAnimatable target, T value, T startValue) : IAnimationFrame
+// {
+//     public IAnimatable Target { get; init; } = target;
+//     public T Value { get; init; } = value;
+//     public T StartValue { get; init; } = startValue;
+//     public T GetAbsoluteValue() => ValueProcessorManager.Add(StartValue, Value);
+//     object IAnimationFrame.StartValue => StartValue!;
+//     object IAnimationFrame.Value => Value!;
+//     object IAnimationFrame.GetAbsoluteValue() => GetAbsoluteValue()!;
+// }