Allow plugins to use web URL's for icon paths

Flow.Launcher.Core/ExternalPlugins/PluginsManifest.cs

@@ -29,13 +29,13 @@ public static async Task UpdateManifestAsync(CancellationToken token = default)
                 var request = new HttpRequestMessage(HttpMethod.Get, manifestFileUrl);
                 request.Headers.Add("If-None-Match", latestEtag);
 
-                var response = await Http.SendAsync(request, token).ConfigureAwait(false);
+                using var response = await Http.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false);
 
                 if (response.StatusCode == HttpStatusCode.OK)
                 {
                     Log.Info($"|PluginsManifest.{nameof(UpdateManifestAsync)}|Fetched plugins from manifest repo");
 
-                    var json = await response.Content.ReadAsStreamAsync(token).ConfigureAwait(false);
+                    await using var json = await response.Content.ReadAsStreamAsync(token).ConfigureAwait(false);
 
                     UserPlugins = await JsonSerializer.DeserializeAsync<List<UserPlugin>>(json, cancellationToken: token).ConfigureAwait(false);
 
@@ -56,4 +56,4 @@ public static async Task UpdateManifestAsync(CancellationToken token = default)
             }
         }
     }
-}
+}

Flow.Launcher.Core/Updater.cs

@@ -79,7 +79,7 @@ public async Task UpdateAppAsync(IPublicAPI api, bool silentUpdate = true)
                     await updateManager.CreateUninstallerRegistryEntry().ConfigureAwait(false);
                 }
 
-                var newVersionTips = NewVersinoTips(newReleaseVersion.ToString());
+                var newVersionTips = NewVersionTips(newReleaseVersion.ToString());
 
                 Log.Info($"|Updater.UpdateApp|Update success:{newVersionTips}");
 
@@ -137,10 +137,10 @@ private async Task<UpdateManager> GitHubUpdateManagerAsync(string repository)
             return manager;
         }
 
-        public string NewVersinoTips(string version)
+        public string NewVersionTips(string version)
         {
-            var translater = InternationalizationManager.Instance;
-            var tips = string.Format(translater.GetTranslation("newVersionTips"), version);
+            var translator = InternationalizationManager.Instance;
+            var tips = string.Format(translator.GetTranslation("newVersionTips"), version);
 
             return tips;
         }

Flow.Launcher.Infrastructure/Http/Http.cs

@@ -68,7 +68,7 @@ public static void UpdateProxy(ProxyProperty property)
                             var userName when string.IsNullOrEmpty(userName) =>
                                 (new Uri($"http://{Proxy.Server}:{Proxy.Port}"), null),
                             _ => (new Uri($"http://{Proxy.Server}:{Proxy.Port}"),
-                                    new NetworkCredential(Proxy.UserName, Proxy.Password))
+                                new NetworkCredential(Proxy.UserName, Proxy.Password))
                         },
                         _ => (null, null)
                     },
@@ -79,7 +79,7 @@ var userName when string.IsNullOrEmpty(userName) =>
                     _ => throw new ArgumentOutOfRangeException()
                 };
             }
-            catch(UriFormatException e)
+            catch (UriFormatException e)
             {
                 API.ShowMsg("Please try again", "Unable to parse Http Proxy");
                 Log.Exception("Flow.Launcher.Infrastructure.Http", "Unable to parse Uri", e);
@@ -94,7 +94,7 @@ public static async Task DownloadAsync([NotNull] string url, [NotNull] string fi
                 if (response.StatusCode == HttpStatusCode.OK)
                 {
                     await using var fileStream = new FileStream(filePath, FileMode.CreateNew);
-                    await response.Content.CopyToAsync(fileStream);
+                    await response.Content.CopyToAsync(fileStream, token);
                 }
                 else
                 {
@@ -117,7 +117,7 @@ public static async Task DownloadAsync([NotNull] string url, [NotNull] string fi
         public static Task<string> GetAsync([NotNull] string url, CancellationToken token = default)
         {
             Log.Debug($"|Http.Get|Url <{url}>");
-            return GetAsync(new Uri(url.Replace("#", "%23")), token);
+            return GetAsync(new Uri(url), token);
         }
 
         /// <summary>
@@ -130,36 +130,57 @@ public static async Task<string> GetAsync([NotNull] Uri url, CancellationToken t
         {
             Log.Debug($"|Http.Get|Url <{url}>");
             using var response = await client.GetAsync(url, token);
-            var content = await response.Content.ReadAsStringAsync();
-            if (response.StatusCode == HttpStatusCode.OK)
-            {
-                return content;
-            }
-            else
+            var content = await response.Content.ReadAsStringAsync(token);
+            if (response.StatusCode != HttpStatusCode.OK)
             {
                 throw new HttpRequestException(
                     $"Error code <{response.StatusCode}> with content <{content}> returned from <{url}>");
             }
+
+            return content;
         }
 
         /// <summary>
-        /// Asynchrously get the result as stream from url.
+        /// Send a GET request to the specified Uri with an HTTP completion option and a cancellation token as an asynchronous operation.
+        /// </summary>
+        /// <param name="url">The Uri the request is sent to.</param>
+        /// <param name="completionOption">An HTTP completion option value that indicates when the operation should be considered completed.</param>
+        /// <param name="token">A cancellation token that can be used by other objects or threads to receive notice of cancellation</param>
+        /// <returns></returns>
+        public static Task<Stream> GetStreamAsync([NotNull] string url,
+            CancellationToken token = default) => GetStreamAsync(new Uri(url), token);
+
+
+        /// <summary>
+        /// Send a GET request to the specified Uri with an HTTP completion option and a cancellation token as an asynchronous operation.
         /// </summary>
         /// <param name="url"></param>
+        /// <param name="token"></param>
         /// <returns></returns>
-        public static async Task<Stream> GetStreamAsync([NotNull] string url, CancellationToken token = default)
+        public static async Task<Stream> GetStreamAsync([NotNull] Uri url,
+            CancellationToken token = default)
+        {
+            Log.Debug($"|Http.Get|Url <{url}>");
+            return await client.GetStreamAsync(url, token);
+        }
+
+        public static async Task<HttpResponseMessage> GetResponseAsync(string url, HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead,
+            CancellationToken token = default)
+            => await GetResponseAsync(new Uri(url), completionOption, token);
+
+        public static async Task<HttpResponseMessage> GetResponseAsync([NotNull] Uri url, HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead,
+            CancellationToken token = default)
         {
             Log.Debug($"|Http.Get|Url <{url}>");
-            var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, token);
-            return await response.Content.ReadAsStreamAsync();
+            return await client.GetAsync(url, completionOption, token);
         }
 
         /// <summary>
         /// Asynchrously send an HTTP request.
         /// </summary>
-        public static async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken token = default)
+        public static async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead, CancellationToken token = default)
         {
-            return await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token);
+            return await client.SendAsync(request, completionOption, token);
         }
     }
 }

Flow.Launcher.Infrastructure/Image/ImageCache.cs

@@ -25,41 +25,41 @@ public ImageUsage(int usage, ImageSource image)
     public class ImageCache
     {
         private const int MaxCached = 50;
-        public ConcurrentDictionary<string, ImageUsage> Data { get; private set; } = new ConcurrentDictionary<string, ImageUsage>();
+        public ConcurrentDictionary<(string, bool), ImageUsage> Data { get; } = new();
         private const int permissibleFactor = 2;
         private SemaphoreSlim semaphore = new(1, 1);
 
-        public void Initialization(Dictionary<string, int> usage)
+        public void Initialization(Dictionary<(string, bool), int> usage)
         {
             foreach (var key in usage.Keys)
             {
                 Data[key] = new ImageUsage(usage[key], null);
             }
         }
 
-        public ImageSource this[string path]
+        public ImageSource this[string path, bool isFullImage = false]
         {
             get
             {
-                if (Data.TryGetValue(path, out var value))
+                if (!Data.TryGetValue((path, isFullImage), out var value))
                 {
-                    value.usage++;
-                    return value.imageSource;
+                    return null;
                 }
+                value.usage++;
+                return value.imageSource;
 
-                return null;
             }
             set
             {
                 Data.AddOrUpdate(
-                        path,
-                        new ImageUsage(0, value),
-                        (k, v) =>
-                            {
-                                v.imageSource = value;
-                                v.usage++;
-                                return v;
-                            }
+                    (path, isFullImage),
+                    new ImageUsage(0, value),
+                    (k, v) =>
+                    {
+                        v.imageSource = value;
+                        v.usage++;
+                        return v;
+                    }
                 );
 
                 SliceExtra();
@@ -82,9 +82,9 @@ async void SliceExtra()
             }
         }
 
-        public bool ContainsKey(string key)
+        public bool ContainsKey(string key, bool isFullImage)
         {
-            return key is not null && Data.ContainsKey(key) && Data[key].imageSource != null;
+            return key is not null && Data.ContainsKey((key, isFullImage)) && Data[(key, isFullImage)].imageSource != null;
         }
 
         public int CacheSize()
@@ -100,4 +100,4 @@ public int UniqueImagesInCache()
             return Data.Values.Select(x => x.imageSource).Distinct().Count();
         }
     }
-}
+}