check for framework thread on running actions, fix palette+ constantly sending update for chara data to create

MareSynchronos/Interop/IpcManager.cs

@@ -581,7 +581,7 @@ public sealed class IpcManager : DisposableMediatorSubscriberBase
 
     private void OnPalettePlusPaletteChange(Character character, string palette)
     {
-        Mediator.Publish(new PalettePlusMessage());
+        Mediator.Publish(new PalettePlusMessage(character));
     }
 
     private void PenumbraDispose()

MareSynchronos/MareSynchronos.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Authors></Authors>
     <Company></Company>
-    <Version>0.8.3</Version>
+    <Version>0.8.4</Version>
     <Description></Description>
     <Copyright></Copyright>
     <PackageProjectUrl>https://github.com/Penumbra-Sync/client</PackageProjectUrl>

MareSynchronos/PlayerData/Services/CacheCreationService.cs

@@ -15,7 +15,7 @@ public sealed class CacheCreationService : DisposableMediatorSubscriberBase
     private readonly PlayerDataFactory _characterDataFactory;
     private readonly CancellationTokenSource _cts = new();
     private readonly CharacterData _playerData = new();
-    private readonly List<GameObjectHandler> _playerRelatedObjects = new();
+    private readonly Dictionary<ObjectKind, GameObjectHandler> _playerRelatedObjects = new();
     private Task? _cacheCreationTask;
     private CancellationTokenSource _palettePlusCts = new();
 
@@ -24,21 +24,23 @@ public sealed class CacheCreationService : DisposableMediatorSubscriberBase
     {
         _characterDataFactory = characterDataFactory;
 
+        _playerRelatedObjects[ObjectKind.Player] =
+            gameObjectHandlerFactory(ObjectKind.Player, () => dalamudUtil.PlayerPointer, true);
+        _playerRelatedObjects[ObjectKind.MinionOrMount] =
+            gameObjectHandlerFactory(ObjectKind.Player, () => dalamudUtil.GetMinionOrMount(), true);
+        _playerRelatedObjects[ObjectKind.Pet] =
+            gameObjectHandlerFactory(ObjectKind.Pet, () => dalamudUtil.GetPet(), true);
+        _playerRelatedObjects[ObjectKind.Companion] =
+            gameObjectHandlerFactory(ObjectKind.Companion, () => dalamudUtil.GetCompanion(), true);
+
         Mediator.Subscribe<CreateCacheForObjectMessage>(this, (msg) =>
         {
+            Logger.LogDebug("Received CreateCacheForObject for {handler}, updating player", msg.ObjectToCreateFor);
             _cacheCreateLock.Wait();
             _cachesToCreate[msg.ObjectToCreateFor.ObjectKind] = msg.ObjectToCreateFor;
             _cacheCreateLock.Release();
         });
 
-        _playerRelatedObjects.AddRange(new List<GameObjectHandler>()
-        {
-            gameObjectHandlerFactory(ObjectKind.Player, () => dalamudUtil.PlayerPointer, true),
-            gameObjectHandlerFactory(ObjectKind.MinionOrMount, () => dalamudUtil.GetMinionOrMount(), true),
-            gameObjectHandlerFactory(ObjectKind.Pet, () => dalamudUtil.GetPet(), true),
-            gameObjectHandlerFactory(ObjectKind.Companion, () => dalamudUtil.GetCompanion(), true),
-        });
-
         Mediator.Subscribe<ClearCacheForObjectMessage>(this, (msg) =>
         {
             Task.Run(() =>
@@ -50,24 +52,43 @@ public sealed class CacheCreationService : DisposableMediatorSubscriberBase
         });
 
         Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (msg) => ProcessCacheCreation());
-        Mediator.Subscribe<CustomizePlusMessage>(this, async (_) => await AddPlayerCacheToCreate().ConfigureAwait(false));
+        Mediator.Subscribe<CustomizePlusMessage>(this, async (_) =>
-        Mediator.Subscribe<HeelsOffsetMessage>(this, async (_) => await AddPlayerCacheToCreate().ConfigureAwait(false));
+        {
-        Mediator.Subscribe<PalettePlusMessage>(this, (_) => PalettePlusChanged());
+            Logger.LogDebug("Received CustomizePlus change, updating player");
-        Mediator.Subscribe<PenumbraModSettingChangedMessage>(this, async (msg) => await AddPlayerCacheToCreate().ConfigureAwait(false));
+            await AddPlayerCacheToCreate().ConfigureAwait(false);
+        });
+        Mediator.Subscribe<HeelsOffsetMessage>(this, async (_) =>
+        {
+            Logger.LogDebug("Received Heels Offset change, updating player");
+            await AddPlayerCacheToCreate().ConfigureAwait(false);
+        });
+        Mediator.Subscribe<PalettePlusMessage>(this, (msg) =>
+        {
+            if (msg.Character.Address == _playerRelatedObjects[ObjectKind.Player].Address)
+            {
+                Logger.LogDebug("Received PalettePlus change, updating player");
+                PalettePlusChanged();
+            }
+        });
+        Mediator.Subscribe<PenumbraModSettingChangedMessage>(this, async (msg) =>
+        {
+            Logger.LogDebug("Received Penumbra Mod settings change, updating player");
+            await AddPlayerCacheToCreate().ConfigureAwait(false);
+        });
     }
 
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
 
-        _playerRelatedObjects.ForEach(p => p.Dispose());
+        _playerRelatedObjects.Values.ToList().ForEach(p => p.Dispose());
         _cts.Dispose();
     }
 
     private async Task AddPlayerCacheToCreate()
     {
         await _cacheCreateLock.WaitAsync().ConfigureAwait(false);
-        _cachesToCreate[ObjectKind.Player] = _playerRelatedObjects.First(p => p.ObjectKind == ObjectKind.Player);
+        _cachesToCreate[ObjectKind.Player] = _playerRelatedObjects[ObjectKind.Player];
         _cacheCreateLock.Release();
     }
 

MareSynchronos/Services/DalamudUtilService.cs

@@ -157,14 +157,20 @@ public class DalamudUtilService : IHostedService
 
     public async Task RunOnFrameworkThread(Action act)
     {
-        _logger.LogTrace("Running Action on framework thread: {act}", act);
+        _logger.LogTrace("Running Action on framework thread (FrameworkContext: {ctx}): {act}", _framework.IsInFrameworkUpdateThread, act);
-        await _framework.RunOnFrameworkThread(act).ConfigureAwait(false);
+        if (!_framework.IsInFrameworkUpdateThread)
+            await _framework.RunOnFrameworkThread(act).ConfigureAwait(false);
+        else
+            act();
     }
 
     public async Task<T> RunOnFrameworkThread<T>(Func<T> func)
     {
-        _logger.LogTrace("Running Func on framework thread: {func}", func);
+        _logger.LogTrace("Running Func on framework thread (FrameworkContext: {ctx}): {act}", _framework.IsInFrameworkUpdateThread, func);
-        return await _framework.RunOnFrameworkThread(func).ConfigureAwait(false);
+        if (!_framework.IsInFrameworkUpdateThread)
+            return await _framework.RunOnFrameworkThread(func).ConfigureAwait(false);
+        else
+            return func.Invoke();
     }
 
     public Task StartAsync(CancellationToken cancellationToken)

MareSynchronos/Services/Mediator/Messages.cs

@@ -1,4 +1,5 @@
-using Dalamud.Interface.Internal.Notifications;
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Interface.Internal.Notifications;
 using MareSynchronos.API.Dto;
 using MareSynchronos.PlayerData.Handlers;
 using MareSynchronos.WebAPI.Files.Models;
@@ -30,7 +31,7 @@ public record PenumbraRedrawMessage(IntPtr Address, int ObjTblIdx, bool WasReque
 public record HeelsOffsetMessage : IMessage;
 public record PenumbraResourceLoadMessage(IntPtr GameObject, string GamePath, string FilePath) : IMessage;
 public record CustomizePlusMessage : IMessage;
-public record PalettePlusMessage : IMessage;
+public record PalettePlusMessage(Character Character) : IMessage;
 public record PlayerChangedMessage(API.Data.CharacterData Data) : IMessage;
 public record CharacterChangedMessage(GameObjectHandler GameObjectHandler) : IMessage;
 public record TransientResourceChangedMessage(IntPtr Address) : IMessage;