rework/cleanup of onlineplayermanager

MareSynchronos/PlayerData/Handlers/GameObjectHandler.cs

@@ -230,7 +230,6 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
             if (equipDiff && !_isOwnedObject) // send the message out immediately and cancel out, no reason to continue if not self
             {
                 Logger.LogTrace("[{this}] Changed", this);
-                Mediator.Publish(new CharacterChangedMessage(this));
                 return;
             }
 

MareSynchronos/PlayerData/Handlers/PairHandler.cs

@@ -295,9 +295,9 @@ public sealed class PairHandler : DisposableMediatorSubscriberBase
         var handler = changes.Key switch
         {
             ObjectKind.Player => _charaHandler!,
-            ObjectKind.Companion => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetCompanion(ptr), isWatched: false).ConfigureAwait(false),
-            ObjectKind.MinionOrMount => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetMinionOrMount(ptr), isWatched: false).ConfigureAwait(false),
-            ObjectKind.Pet => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetPet(ptr), isWatched: false).ConfigureAwait(false),
+            ObjectKind.Companion => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetCompanionPtr(ptr), isWatched: false).ConfigureAwait(false),
+            ObjectKind.MinionOrMount => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetMinionOrMountPtr(ptr), isWatched: false).ConfigureAwait(false),
+            ObjectKind.Pet => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetPetPtr(ptr), isWatched: false).ConfigureAwait(false),
             _ => throw new NotSupportedException("ObjectKind not supported: " + changes.Key)
         };
 
@@ -540,7 +540,6 @@ public sealed class PairHandler : DisposableMediatorSubscriberBase
         {
             Guid appData = Guid.NewGuid();
             IsVisible = true;
-            Mediator.Publish(new PairHandlerVisibleMessage(this));
             if (_cachedData != null)
             {
                 Logger.LogTrace("[BASE-{appBase}] {this} visibility changed, now: {visi}, cached data exists", appData, this, IsVisible);

MareSynchronos/PlayerData/Pairs/OnlinePlayerManager.cs

@@ -1,75 +0,0 @@
-using MareSynchronos.API.Data;
-using MareSynchronos.PlayerData.Handlers;
-using MareSynchronos.Services;
-using MareSynchronos.Services.Mediator;
-using MareSynchronos.Utils;
-using MareSynchronos.WebAPI;
-using MareSynchronos.WebAPI.Files;
-using Microsoft.Extensions.Logging;
-
-namespace MareSynchronos.PlayerData.Pairs;
-
-public class OnlinePlayerManager : DisposableMediatorSubscriberBase
-{
-    private readonly ApiController _apiController;
-    private readonly DalamudUtilService _dalamudUtil;
-    private readonly FileUploadManager _fileTransferManager;
-    private readonly HashSet<PairHandler> _newVisiblePlayers = [];
-    private readonly PairManager _pairManager;
-    private CharacterData? _lastSentData;
-
-    public OnlinePlayerManager(ILogger<OnlinePlayerManager> logger, ApiController apiController, DalamudUtilService dalamudUtil,
-        PairManager pairManager, MareMediator mediator, FileUploadManager fileTransferManager) : base(logger, mediator)
-    {
-        _apiController = apiController;
-        _dalamudUtil = dalamudUtil;
-        _pairManager = pairManager;
-        _fileTransferManager = fileTransferManager;
-        Mediator.Subscribe<PlayerChangedMessage>(this, (_) => PlayerManagerOnPlayerHasChanged());
-        Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (_) => FrameworkOnUpdate());
-        Mediator.Subscribe<CharacterDataCreatedMessage>(this, (msg) =>
-        {
-            var newData = msg.CharacterData;
-            if (_lastSentData == null || (!string.Equals(newData.DataHash.Value, _lastSentData.DataHash.Value, StringComparison.Ordinal)))
-            {
-                Logger.LogDebug("Pushing data for visible players");
-                _lastSentData = newData;
-                PushCharacterData(_pairManager.GetVisibleUsers());
-            }
-            else
-            {
-                Logger.LogDebug("Not sending data for {hash}", newData.DataHash.Value);
-            }
-        });
-        Mediator.Subscribe<PairHandlerVisibleMessage>(this, (msg) => _newVisiblePlayers.Add(msg.Player));
-        Mediator.Subscribe<ConnectedMessage>(this, (_) => PushCharacterData(_pairManager.GetVisibleUsers()));
-    }
-
-    private void FrameworkOnUpdate()
-    {
-        if (!_dalamudUtil.GetIsPlayerPresent() || !_apiController.IsConnected) return;
-
-        if (!_newVisiblePlayers.Any()) return;
-        var newVisiblePlayers = _newVisiblePlayers.ToList();
-        _newVisiblePlayers.Clear();
-        Logger.LogTrace("Has new visible players, pushing character data");
-        PushCharacterData(newVisiblePlayers.Select(c => c.Pair.UserData).ToList());
-    }
-
-    private void PlayerManagerOnPlayerHasChanged()
-    {
-        PushCharacterData(_pairManager.GetVisibleUsers());
-    }
-
-    private void PushCharacterData(List<UserData> visiblePlayers)
-    {
-        if (visiblePlayers.Any() && _lastSentData != null)
-        {
-            _ = Task.Run(async () =>
-            {
-                var dataToSend = await _fileTransferManager.UploadFiles(_lastSentData.DeepClone(), visiblePlayers).ConfigureAwait(false);
-                await _apiController.PushCharacterData(dataToSend, visiblePlayers).ConfigureAwait(false);
-            });
-        }
-    }
-}

MareSynchronos/PlayerData/Pairs/PairManager.cs

@@ -122,7 +122,7 @@ public sealed class PairManager : DisposableMediatorSubscriberBase
 
     public int GetVisibleUserCount() => _allClientPairs.Count(p => p.Value.IsVisible);
 
-    public List<UserData> GetVisibleUsers() => _allClientPairs.Where(p => p.Value.IsVisible).Select(p => p.Key).ToList();
+    public List<UserData> GetVisibleUsers() => [.. _allClientPairs.Where(p => p.Value.IsVisible).Select(p => p.Key)];
 
     public void MarkPairOffline(UserData user)
     {

MareSynchronos/PlayerData/Pairs/VisibleUserDataDistributor.cs

@@ -0,0 +1,96 @@
+using MareSynchronos.API.Data;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using MareSynchronos.WebAPI;
+using MareSynchronos.WebAPI.Files;
+using MessagePack.Formatters;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Pairs;
+
+public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
+{
+    private readonly ApiController _apiController;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly FileUploadManager _fileTransferManager;
+    private readonly PairManager _pairManager;
+    private CharacterData? _lastCreatedData;
+    private readonly List<UserData> _previouslyVisiblePlayers = [];
+    private Task<CharacterData>? _fileUploadTask = null;
+    private readonly HashSet<UserData> _usersToPushDataTo = [];
+
+    public VisibleUserDataDistributor(ILogger<VisibleUserDataDistributor> logger, ApiController apiController, DalamudUtilService dalamudUtil,
+        PairManager pairManager, MareMediator mediator, FileUploadManager fileTransferManager) : base(logger, mediator)
+    {
+        _apiController = apiController;
+        _dalamudUtil = dalamudUtil;
+        _pairManager = pairManager;
+        _fileTransferManager = fileTransferManager;
+        Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (_) => FrameworkOnUpdate());
+        Mediator.Subscribe<CharacterDataCreatedMessage>(this, (msg) =>
+        {
+            var newData = msg.CharacterData;
+            if (_lastCreatedData == null || (!string.Equals(newData.DataHash.Value, _lastCreatedData.DataHash.Value, StringComparison.Ordinal)))
+            {
+                Logger.LogDebug("Pushing data for visible players");
+                _lastCreatedData = newData;
+                PushToAllVisibleUsers(forced: true);
+            }
+            else
+            {
+                Logger.LogDebug("Not sending data for {hash}", newData.DataHash.Value);
+            }
+        });
+
+        Mediator.Subscribe<ConnectedMessage>(this, (_) => PushToAllVisibleUsers());
+        Mediator.Subscribe<DisconnectedMessage>(this, (_) => _previouslyVisiblePlayers.Clear());
+    }
+
+    private void PushToAllVisibleUsers(bool forced = false)
+    {
+        foreach (var user in _pairManager.GetVisibleUsers())
+        {
+            _usersToPushDataTo.Add(user);
+        }
+        PushCharacterData(forced);
+    }
+
+    private void FrameworkOnUpdate()
+    {
+        if (!_dalamudUtil.GetIsPlayerPresent() || !_apiController.IsConnected) return;
+
+        var allVisibleUsers = _pairManager.GetVisibleUsers();
+        var newVisibleUsers = allVisibleUsers.Except(_previouslyVisiblePlayers).ToList();
+        _previouslyVisiblePlayers.Clear();
+        _previouslyVisiblePlayers.AddRange(allVisibleUsers);
+        if (newVisibleUsers.Count == 0) return;
+
+        Logger.LogTrace("Has new visible players, pushing character data to {users}", string.Join(", ", newVisibleUsers.Select(k => k.AliasOrUID)));
+        foreach (var user in newVisibleUsers)
+        {
+            _usersToPushDataTo.Add(user);
+        }
+        PushCharacterData();
+    }
+
+    private void PushCharacterData(bool forced = false)
+    {
+        if (_lastCreatedData == null) return;
+
+        _ = Task.Run(async () =>
+        {
+            if (_fileUploadTask == null || (_fileUploadTask?.IsCompleted ?? false) || forced)
+            {
+                _fileUploadTask = _fileTransferManager.UploadFiles(_lastCreatedData.DeepClone(), [.. _usersToPushDataTo]);
+            }
+
+            if (_fileUploadTask != null)
+            {
+                var dataToSend = await _fileUploadTask.ConfigureAwait(false);
+                await _apiController.PushCharacterData(dataToSend, [.. _usersToPushDataTo]).ConfigureAwait(false);
+                _usersToPushDataTo.Clear();
+            }
+        });
+    }
+}

MareSynchronos/PlayerData/Services/CacheCreationService.cs

@@ -42,13 +42,13 @@ public sealed class CacheCreationService : DisposableMediatorSubscriberBase
             AddCacheToCreate(msg.ObjectToCreateFor.ObjectKind);
         });
 
-        _playerRelatedObjects[ObjectKind.Player] = gameObjectHandlerFactory.Create(ObjectKind.Player, dalamudUtil.GetPlayerPointer, isWatched: true)
+        _playerRelatedObjects[ObjectKind.Player] = gameObjectHandlerFactory.Create(ObjectKind.Player, dalamudUtil.GetPlayerPtr, isWatched: true)
             .GetAwaiter().GetResult();
-        _playerRelatedObjects[ObjectKind.MinionOrMount] = gameObjectHandlerFactory.Create(ObjectKind.MinionOrMount, () => dalamudUtil.GetMinionOrMount(), isWatched: true)
+        _playerRelatedObjects[ObjectKind.MinionOrMount] = gameObjectHandlerFactory.Create(ObjectKind.MinionOrMount, () => dalamudUtil.GetMinionOrMountPtr(), isWatched: true)
             .GetAwaiter().GetResult();
-        _playerRelatedObjects[ObjectKind.Pet] = gameObjectHandlerFactory.Create(ObjectKind.Pet, () => dalamudUtil.GetPet(), isWatched: true)
+        _playerRelatedObjects[ObjectKind.Pet] = gameObjectHandlerFactory.Create(ObjectKind.Pet, () => dalamudUtil.GetPetPtr(), isWatched: true)
             .GetAwaiter().GetResult();
-        _playerRelatedObjects[ObjectKind.Companion] = gameObjectHandlerFactory.Create(ObjectKind.Companion, () => dalamudUtil.GetCompanion(), isWatched: true)
+        _playerRelatedObjects[ObjectKind.Companion] = gameObjectHandlerFactory.Create(ObjectKind.Companion, () => dalamudUtil.GetCompanionPtr(), isWatched: true)
             .GetAwaiter().GetResult();
 
         Mediator.Subscribe<ClassJobChangedMessage>(this, (msg) =>
@@ -229,7 +229,6 @@ public sealed class CacheCreationService : DisposableMediatorSubscriberBase
             catch (OperationCanceledException)
             {
                 Logger.LogDebug("Cache Creation cancelled");
-                linkedCts.Dispose();
             }
             catch (Exception ex)
             {