work done on the ipc

LightlessSync/Interop/Ipc/Framework/IpcFramework.cs

@@ -0,0 +1,193 @@
+using Dalamud.Plugin;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace LightlessSync.Interop.Ipc.Framework;
+
+public enum IpcConnectionState
+{
+    Unknown = 0,
+    MissingPlugin = 1,
+    VersionMismatch = 2,
+    PluginDisabled = 3,
+    NotReady = 4,
+    Available = 5,
+    Error = 6,
+}
+
+public sealed record IpcServiceDescriptor(string InternalName, string DisplayName, Version MinimumVersion)
+{
+    public override string ToString()
+        => $"{DisplayName} (>= {MinimumVersion})";
+}
+
+public interface IIpcService : IDisposable
+{
+    IpcServiceDescriptor Descriptor { get; }
+    IpcConnectionState State { get; }
+    IDalamudPluginInterface PluginInterface { get; }
+    bool APIAvailable { get; }
+    void CheckAPI();
+}
+
+public interface IIpcInterop : IDisposable
+{
+    string Name { get; }
+    void OnConnectionStateChanged(IpcConnectionState state);
+}
+
+public abstract class IpcInteropBase : IIpcInterop
+{
+    protected IpcInteropBase(ILogger logger)
+    {
+        Logger = logger;
+    }
+
+    protected ILogger Logger { get; }
+
+    protected IpcConnectionState State { get; private set; } = IpcConnectionState.Unknown;
+
+    protected bool IsAvailable => State == IpcConnectionState.Available;
+
+    public abstract string Name { get; }
+
+    public void OnConnectionStateChanged(IpcConnectionState state)
+    {
+        if (State == state)
+        {
+            return;
+        }
+
+        var previous = State;
+        State = state;
+        HandleStateChange(previous, state);
+    }
+
+    protected abstract void HandleStateChange(IpcConnectionState previous, IpcConnectionState current);
+
+    public virtual void Dispose()
+    {
+    }
+}
+
+public abstract class IpcServiceBase : DisposableMediatorSubscriberBase, IIpcService
+{
+    private readonly List<IIpcInterop> _interops = new();
+
+    protected IpcServiceBase(
+        ILogger logger,
+        LightlessMediator mediator,
+        IDalamudPluginInterface pluginInterface,
+        IpcServiceDescriptor descriptor) : base(logger, mediator)
+    {
+        PluginInterface = pluginInterface;
+        Descriptor = descriptor;
+    }
+
+    protected IDalamudPluginInterface PluginInterface { get; }
+
+    IDalamudPluginInterface IIpcService.PluginInterface => PluginInterface;
+
+    protected IpcServiceDescriptor Descriptor { get; }
+
+    IpcServiceDescriptor IIpcService.Descriptor => Descriptor;
+
+    public IpcConnectionState State { get; private set; } = IpcConnectionState.Unknown;
+
+    public bool APIAvailable => State == IpcConnectionState.Available;
+
+    public virtual void CheckAPI()
+    {
+        var newState = EvaluateState();
+        UpdateState(newState);
+    }
+
+    protected virtual IpcConnectionState EvaluateState()
+    {
+        try
+        {
+            var plugin = PluginInterface.InstalledPlugins
+                .FirstOrDefault(p => string.Equals(p.InternalName, Descriptor.InternalName, StringComparison.OrdinalIgnoreCase));
+
+            if (plugin == null)
+            {
+                return IpcConnectionState.MissingPlugin;
+            }
+
+            if (plugin.Version < Descriptor.MinimumVersion)
+            {
+                return IpcConnectionState.VersionMismatch;
+            }
+
+            if (!IsPluginEnabled())
+            {
+                return IpcConnectionState.PluginDisabled;
+            }
+
+            if (!IsPluginReady())
+            {
+                return IpcConnectionState.NotReady;
+            }
+
+            return IpcConnectionState.Available;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogDebug(ex, "Failed to evaluate IPC state for {Service}", Descriptor.DisplayName);
+            return IpcConnectionState.Error;
+        }
+    }
+
+    protected virtual bool IsPluginEnabled()
+        => true;
+
+    protected virtual bool IsPluginReady()
+        => true;
+
+    protected TInterop RegisterInterop<TInterop>(TInterop interop)
+        where TInterop : IIpcInterop
+    {
+        _interops.Add(interop);
+        interop.OnConnectionStateChanged(State);
+        return interop;
+    }
+
+    private void UpdateState(IpcConnectionState newState)
+    {
+        if (State == newState)
+        {
+            return;
+        }
+
+        var previous = State;
+        State = newState;
+        OnConnectionStateChanged(previous, newState);
+
+        foreach (var interop in _interops)
+        {
+            interop.OnConnectionStateChanged(newState);
+        }
+    }
+
+    protected virtual void OnConnectionStateChanged(IpcConnectionState previous, IpcConnectionState current)
+    {
+        Logger.LogTrace("{Service} IPC state transitioned from {Previous} to {Current}", Descriptor.DisplayName, previous, current);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        if (!disposing)
+        {
+            return;
+        }
+
+        for (var i = _interops.Count - 1; i >= 0; --i)
+        {
+            _interops[i].Dispose();
+        }
+
+        _interops.Clear();
+    }
+}