Show champs ingame

LeagueAPI/APIClient.cs

@@ -24,6 +24,8 @@ public class APIClient : IDisposable
 
     private readonly Dictionary<string, ChampionResponse> _championResponseCache = [];
 
+    private readonly CachingHttpClient _ddragonClient = new();
+
     public APIClient()
     {
         _lcuHttpClient = new(new LcuHttpClientHandler());
@@ -81,12 +83,12 @@ public class APIClient : IDisposable
     }
 
     #region DDragon
-    private static async Task<string> DDragonGetAsync(string path)
+    private async Task<string> DDragonGetAsync(string path)
     {
-        return await CachingHttpClient.GetStringAsync($"{DDRAGON_BASE_URL}{path}");
+        return await _ddragonClient.GetStringAsync($"{DDRAGON_BASE_URL}{path}");
     }
 
-    private static async Task<T?> DDragonGetAsync<T>(string path)
+    private async Task<T?> DDragonGetAsync<T>(string path)
     {
         string json = await DDragonGetAsync(path);
         return JsonSerializer.Deserialize<T>(json);
@@ -135,6 +137,17 @@ public class APIClient : IDisposable
 
         return championData.FirstOrDefault(c => c.Id == id);
     }
+
+    public async Task<int> GetChampionIdByNameAsync(string name)
+    {
+        ChampionData[] championData = await GetAllChampionsAsync();
+        if (championData is not { Length: > 0 })
+        {
+            return -1;
+        }
+
+        return championData.FirstOrDefault(c => c.Name == name)?.Id ?? -1;
+    }
     #endregion
 
     #region IDisposable
@@ -145,6 +158,7 @@ public class APIClient : IDisposable
             if (disposing)
             {
                 _lcuHttpClient?.Dispose();
+                _ddragonClient?.Dispose();
             }
             _championResponseCache?.Clear();
 

LeagueAPI/CachingHttpClient.cs

@@ -1,18 +1,77 @@
 namespace LeagueAPI;
 
-public class HttpCache : Dictionary<string, string> { }
-
-public static class CachingHttpClient
+public class HttpCache : Dictionary<string, InvalidatableCacheObject<string>> { }
+public record struct InvalidatableCacheObject<T>(
+    T Value,
+    DateTime? InvalidateTime = null
+    )
 {
-    private static HttpCache _cache = ResourceService.GetHttpCache() ?? [];
-    private static HttpClient _client = new();
-
-    public static async Task<string> GetStringAsync(string requestUri)
+    public readonly bool IsValid()
     {
-        if (_cache.TryGetValue(requestUri, out string? response))
-        {
-            return response;
-        }
-        return await _client.GetStringAsync(requestUri);
+        return !InvalidateTime.HasValue || InvalidateTime < DateTime.UtcNow;
     }
 }
+
+public class CachingHttpClient : IDisposable
+{
+    private bool _isDisposed;
+    private readonly HttpCache _cache = ResourceService.GetHttpCache() ?? [];
+    private readonly HttpClient _client = new();
+
+    public CachingHttpClient(bool insecure = false)
+    {
+        if (insecure)
+        {
+            HttpClientHandler handler = new()
+            {
+                ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
+            };
+            _client = new(handler);
+        }
+        else
+        {
+            _client = new();
+        }
+    }
+
+    public async Task<string> GetStringAsync(string requestUri, TimeSpan? invalidateAfter = null)
+    {
+        if (_cache.TryGetValue(requestUri, out InvalidatableCacheObject<string> response) && response.IsValid())
+        {
+            return response.Value;
+        }
+        string result = await _client.GetStringAsync(requestUri);
+        if (invalidateAfter is not null && invalidateAfter > TimeSpan.Zero)
+        {
+            _cache[requestUri] = new(result, DateTime.UtcNow + invalidateAfter);
+        }
+        else
+        {
+            _cache[requestUri] = new(result);
+        }
+        return result;
+    }
+
+    #region IDisposable
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_isDisposed)
+        {
+            if (disposing)
+            {
+                _client?.Dispose();
+            }
+
+            _cache?.Clear();
+            _isDisposed = true;
+        }
+    }
+
+    public void Dispose()
+    {
+        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+    #endregion
+}

LeagueAPI/Models/GameClient/PlayerResponse.cs

@@ -0,0 +1,23 @@
+using System.Text.Json.Serialization;
+
+namespace LeagueAPI.Models.GameClient;
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum TeamId
+{
+    ALL,
+    UNKNOWN,
+    ORDER,
+    CHAOS,
+    NEUTRAL,
+}
+
+public record class PlayerResponse(
+    [property: JsonPropertyName("championName")] string ChampionName,
+    [property: JsonPropertyName("isBot")] bool IsBot,
+    [property: JsonPropertyName("rawChampionName")] string RawChampionName,
+    [property: JsonPropertyName("team")] TeamId Team,
+    [property: JsonPropertyName("riotId")] string RiotId,
+    [property: JsonPropertyName("riotIdGameName")] string RiotIdGameName,
+    [property: JsonPropertyName("riotIdTagLine")] string RiotIdTagLine
+    );

LeagueAPI/Utils/ProcessWatcher.cs

@@ -0,0 +1,69 @@
+using System.Diagnostics;
+
+namespace LeagueAPI.Utils;
+
+public class ProcessWatcher : IDisposable
+{
+    private bool _isDisposed;
+    private Timer _timer;
+
+    public bool IsGameRunning { get; private set; } = false;
+
+    public event EventHandler? LeagueOfLegendsExeFound;
+
+    public TimeSpan Interval
+    {
+        get => field;
+        set
+        {
+            if (field != value)
+            {
+                field = value;
+                _timer?.Change(TimeSpan.Zero, value);
+            }
+        }
+    } = TimeSpan.FromSeconds(10);
+
+    public ProcessWatcher()
+    {
+        _timer = new(OnTimerTick, null, TimeSpan.Zero, Interval);
+    }
+
+    private void OnTimerTick(object? state)
+    {
+        if (Process.GetProcessesByName("League of Legends").Length != 0)
+        {
+            if (!IsGameRunning)
+            {
+                LeagueOfLegendsExeFound?.Invoke(this, EventArgs.Empty);
+            }
+            IsGameRunning = true;
+        }
+        else
+        {
+            IsGameRunning = false;
+        }
+    }
+
+    #region IDisposable
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_isDisposed)
+        {
+            if (disposing)
+            {
+                _timer?.Dispose();
+            }
+
+            _isDisposed = true;
+        }
+    }
+
+    public void Dispose()
+    {
+        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+    #endregion
+}