Allow plugins to use web URL's for icon paths

Flow.Launcher.Core/ExternalPlugins/PluginsManifest.cs

@@ -29,7 +29,7 @@ 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)
                 {
@@ -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/ImageLoader.cs

@@ -3,11 +3,14 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Net;
+using System.Net.Http;
 using System.Threading.Tasks;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.Storage;
+using static Flow.Launcher.Infrastructure.Http.Http;
 
 namespace Flow.Launcher.Infrastructure.Image
 {
@@ -23,13 +26,7 @@ public static class ImageLoader
 
         private static readonly string[] ImageExtensions =
         {
-            ".png",
-            ".jpg",
-            ".jpeg",
-            ".gif",
-            ".bmp",
-            ".tiff",
-            ".ico"
+            ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".ico"
         };
 
         public static void Initialize()
@@ -39,21 +36,24 @@ public static void Initialize()
 
             var usage = LoadStorageToConcurrentDictionary();
 
-            foreach (var icon in new[] { Constant.DefaultIcon, Constant.MissingImgIcon })
+            foreach (var icon in new[]
+                     {
+                         Constant.DefaultIcon, Constant.MissingImgIcon
+                     })
             {
                 ImageSource img = new BitmapImage(new Uri(icon));
                 img.Freeze();
                 ImageCache[icon] = img;
             }
 
-            _ = Task.Run(() =>
+            _ = Task.Run(async () =>
             {
-                Stopwatch.Normal("|ImageLoader.Initialize|Preload images cost", () =>
+                await Stopwatch.NormalAsync("|ImageLoader.Initialize|Preload images cost", async () =>
                 {
-                    ImageCache.Data.AsParallel().ForAll(x =>
+                    foreach (var imageUsage in ImageCache.Data)
                     {
-                        Load(x.Key);
-                    });
+                        await LoadAsync(imageUsage.Key);
+                    }
                 });
                 Log.Info($"|ImageLoader.Initialize|Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
             });
@@ -99,7 +99,7 @@ private enum ImageType
             Cache
         }
 
-        private static ImageResult LoadInternal(string path, bool loadFullImage = false)
+        private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool loadFullImage = false)
         {
             ImageResult imageResult;
 
@@ -113,7 +113,28 @@ private static ImageResult LoadInternal(string path, bool loadFullImage = false)
                 {
                     return new ImageResult(ImageCache[path], ImageType.Cache);
                 }
-
+                if (Uri.TryCreate(path, UriKind.RelativeOrAbsolute, out var uriResult)
+                    && (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps))
+                {
+                    // Download image from url
+                    await using var resp = await GetStreamAsync(uriResult);
+                    if (resp == null)
+                    {
+                        return new ImageResult(ImageCache[Constant.MissingImgIcon], ImageType.Error);
+                    }
+                    await using var buffer = new MemoryStream();
+                    await resp.CopyToAsync(buffer);
+                    buffer.Seek(0, SeekOrigin.Begin);
+                    var image = new BitmapImage();
+                    image.BeginInit();
+                    image.CacheOption = BitmapCacheOption.OnLoad;
+                    image.StreamSource = buffer;
+                    image.EndInit();
+                    image.StreamSource = null;
+                    image.Freeze();
+                    ImageCache[path] = image;
+                    return new ImageResult(image, ImageType.ImageFile);
+                }
                 if (path.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
                 {
                     var imageSource = new BitmapImage(new Uri(path));
@@ -218,9 +239,9 @@ public static bool CacheContainImage(string path)
             return ImageCache.ContainsKey(path) && ImageCache[path] != null;
         }
 
-        public static ImageSource Load(string path, bool loadFullImage = false)
+        public static async ValueTask<ImageSource> LoadAsync(string path, bool loadFullImage = false)
         {
-            var imageResult = LoadInternal(path, loadFullImage);
+            var imageResult = await LoadInternalAsync(path, loadFullImage);
 
             var img = imageResult.ImageSource;
             if (imageResult.ImageType != ImageType.Error && imageResult.ImageType != ImageType.Cache)

Flow.Launcher.Plugin/Result.cs

@@ -58,7 +58,13 @@ public string IcoPath
             {
                 if (!string.IsNullOrEmpty(PluginDirectory) && !Path.IsPathRooted(value))
                 {
-                    _icoPath = Path.Combine(value, IcoPath);
+                    string absPath = Path.Combine(value, IcoPath);
+                    // Only convert relative paths if its a valid path
+                    if (File.Exists(absPath))
+                    {
+                        _icoPath = Path.Combine(value, IcoPath);
+                    }
+
                 }
                 else
                 {
@@ -135,9 +141,15 @@ public string PluginDirectory
             set
             {
                 _pluginDirectory = value;
-                if (!string.IsNullOrEmpty(IcoPath) && !Path.IsPathRooted(IcoPath))
+                    if (!string.IsNullOrEmpty(IcoPath) && !Path.IsPathRooted(IcoPath))
                 {
-                    IcoPath = Path.Combine(value, IcoPath);
+                    string absPath = Path.Combine(value, IcoPath);
+                    // Only convert relative paths if its a valid path
+                    if (File.Exists(absPath))
+                    {
+                        IcoPath = absPath;
+                    }
+
                 }
             }
         }

Flow.Launcher/Msg.xaml.cs

@@ -38,10 +38,16 @@ public Msg()
             Storyboard.SetTargetProperty(fadeOutAnimation, new PropertyPath(TopProperty));
             fadeOutStoryboard.Children.Add(fadeOutAnimation);
 
-            imgClose.Source = ImageLoader.Load(Path.Combine(Infrastructure.Constant.ProgramDirectory, "Images\\close.png"));
+            _ = LoadImageAsync();
+
             imgClose.MouseUp += imgClose_MouseUp;
         }
 
+        private async System.Threading.Tasks.Task LoadImageAsync()
+        {
+            imgClose.Source = await ImageLoader.LoadAsync(Path.Combine(Infrastructure.Constant.ProgramDirectory, "Images\\close.png"));
+        }
+
         void imgClose_MouseUp(object sender, MouseButtonEventArgs e)
         {
             if (!closing)
@@ -56,7 +62,7 @@ private void fadeOutStoryboard_Completed(object sender, EventArgs e)
             Close();
         }
 
-        public void Show(string title, string subTitle, string iconPath)
+        public async void Show(string title, string subTitle, string iconPath)
         {
             tbTitle.Text = title;
             tbSubTitle.Text = subTitle;
@@ -66,15 +72,15 @@ public void Show(string title, string subTitle, string iconPath)
             }
             if (!File.Exists(iconPath))
             {
-                imgIco.Source = ImageLoader.Load(Path.Combine(Constant.ProgramDirectory, "Images\\app.png"));
+                imgIco.Source = await ImageLoader.LoadAsync(Path.Combine(Constant.ProgramDirectory, "Images\\app.png"));
             }
             else {
-                imgIco.Source = ImageLoader.Load(iconPath);
+                imgIco.Source = await ImageLoader.LoadAsync(iconPath);
             }
 
             Show();
 
-            Dispatcher.InvokeAsync(async () =>
+            await Dispatcher.InvokeAsync(async () =>
                                    {
                                        if (!closing)
                                        {

Flow.Launcher/SettingWindow.xaml

@@ -1068,7 +1068,7 @@
                                                             Height="32"
                                                             Margin="32,0,0,0"
                                                             FlowDirection="LeftToRight"
-                                                            Source="{Binding Image, IsAsync=True}" />
+                                                            Source="{Binding Image, Mode=OneWay}" />
                                                     </StackPanel>
                                                     <StackPanel Grid.Column="1" Margin="12,0,14,0">
                                                         <TextBlock

Flow.Launcher/ViewModel/PluginViewModel.cs

@@ -1,4 +1,5 @@
-using System.Windows;
+using System.Threading.Tasks;
+using System.Windows;
 using System.Windows.Media;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Infrastructure.Image;
@@ -24,7 +25,23 @@ public PluginPair PluginPair
             }
         }
 
-        public ImageSource Image => ImageLoader.Load(PluginPair.Metadata.IcoPath);
+
+        private async void LoadIconAsync()
+        {
+            Image = await ImageLoader.LoadAsync(PluginPair.Metadata.IcoPath);
+        }
+
+        public ImageSource Image
+        {
+            get
+            {
+                if (_image == ImageLoader.DefaultImage)
+                    LoadIconAsync();
+
+                return _image;
+            }
+            set => _image = value;
+        }
         public bool PluginState
         {
             get => !PluginPair.Metadata.Disabled;
@@ -50,6 +67,7 @@ public Control SettingControl
                         ? new Control() 
                         : settingProvider.CreateSettingPanel() 
                 : null;
+        private ImageSource _image = ImageLoader.DefaultImage;
 
         public Visibility ActionKeywordsVisibility => PluginPair.Metadata.ActionKeywords.Count == 1 ? Visibility.Visible : Visibility.Collapsed;
         public string InitilizaTime => PluginPair.Metadata.InitTime + "ms";