Merge remote-tracking branch 'upstream/dev' into DotNet5Upgrade

Flow.Launcher.Core/Flow.Launcher.Core.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <UseWpf>true</UseWpf>
     <UseWindowsForms>true</UseWindowsForms>
     <OutputType>Library</OutputType>

Flow.Launcher.Core/Plugin/JsonPRCModel.cs

@@ -15,6 +15,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.Json.Serialization;
 using Flow.Launcher.Plugin;
 
 namespace Flow.Launcher.Core.Plugin
@@ -42,6 +43,7 @@ namespace Flow.Launcher.Core.Plugin
 
     public class JsonRPCQueryResponseModel : JsonRPCResponseModel
     {
+        [JsonPropertyName("result")]
         public new List<JsonRPCResult> Result { get; set; }
     }
 

Flow.Launcher.Core/Plugin/JsonRPCPlugin.cs

@@ -147,47 +147,42 @@ namespace Flow.Launcher.Core.Plugin
         {
             try
             {
-                using (var process = Process.Start(startInfo))
+                using var process = Process.Start(startInfo);
+                if (process == null)
                 {
-                    if (process != null)
+                    Log.Error("|JsonRPCPlugin.Execute|Can't start new process");
+                    return string.Empty;
+                }
+
+                using var standardOutput = process.StandardOutput;
+                var result = standardOutput.ReadToEnd();
+                if (string.IsNullOrEmpty(result))
+                {
+                    using (var standardError = process.StandardError)
                     {
-                        using (var standardOutput = process.StandardOutput)
+                        var error = standardError.ReadToEnd();
+                        if (!string.IsNullOrEmpty(error))
                         {
-                            var result = standardOutput.ReadToEnd();
-                            if (string.IsNullOrEmpty(result))
-                            {
-                                using (var standardError = process.StandardError)
-                                {
-                                    var error = standardError.ReadToEnd();
-                                    if (!string.IsNullOrEmpty(error))
-                                    {
-                                        Log.Error($"|JsonRPCPlugin.Execute|{error}");
-                                        return string.Empty;
-                                    }
-                                    else
-                                    {
-                                        Log.Error("|JsonRPCPlugin.Execute|Empty standard output and standard error.");
-                                        return string.Empty;
-                                    }
-                                }
-                            }
-                            else if (result.StartsWith("DEBUG:"))
-                            {
-                                MessageBox.Show(new Form { TopMost = true }, result.Substring(6));
-                                return string.Empty;
-                            }
-                            else
-                            {
-                                return result;
-                            }
+                            Log.Error($"|JsonRPCPlugin.Execute|{error}");
+                            return string.Empty;
+                        }
+                        else
+                        {
+                            Log.Error("|JsonRPCPlugin.Execute|Empty standard output and standard error.");
+                            return string.Empty;
                         }
                     }
-                    else
-                    {
-                        Log.Error("|JsonRPCPlugin.Execute|Can't start new process");
-                        return string.Empty;
-                    }
                 }
+                else if (result.StartsWith("DEBUG:"))
+                {
+                    MessageBox.Show(new Form { TopMost = true }, result.Substring(6));
+                    return string.Empty;
+                }
+                else
+                {
+                    return result;
+                }
+
             }
             catch (Exception e)
             {

Flow.Launcher.Core/Plugin/PluginAssemblyLoader.cs

@@ -20,7 +20,7 @@ namespace Flow.Launcher.Core.Plugin
             dependencyResolver = new AssemblyDependencyResolver(assemblyFilePath);
             assemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(assemblyFilePath));
 
-            referencedPluginPackageDependencyResolver = 
+            referencedPluginPackageDependencyResolver =
                 new AssemblyDependencyResolver(Path.Combine(Constant.ProgramDirectory, "Flow.Launcher.Plugin.dll"));
         }
 
@@ -38,15 +38,15 @@ namespace Flow.Launcher.Core.Plugin
             // that use Newtonsoft.Json
             if (assemblyPath == null || ExistsInReferencedPluginPackage(assemblyName))
                 return null;
-            
+
             return LoadFromAssemblyPath(assemblyPath);
         }
 
-        internal Type FromAssemblyGetTypeOfInterface(Assembly assembly, Type type)
+        internal Type FromAssemblyGetTypeOfInterface(Assembly assembly, params Type[] types)
         {
             var allTypes = assembly.ExportedTypes;
 
-            return allTypes.First(o => o.IsClass && !o.IsAbstract && o.GetInterfaces().Contains(type));
+            return allTypes.First(o => o.IsClass && !o.IsAbstract && o.GetInterfaces().Intersect(types).Any());
         }
 
         internal bool ExistsInReferencedPluginPackage(AssemblyName assemblyName)

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -3,6 +3,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Infrastructure.Logger;
@@ -52,13 +53,14 @@ namespace Flow.Launcher.Core.Plugin
             }
         }
 
-        public static void ReloadData()
+        public static async Task ReloadData()
         {
-            foreach(var plugin in AllPlugins)
+            await Task.WhenAll(AllPlugins.Select(plugin => plugin.Plugin switch
             {
-                var reloadablePlugin = plugin.Plugin as IReloadable;
-                reloadablePlugin?.ReloadData();
-            }
+                IReloadable p => Task.Run(p.ReloadData),
+                IAsyncReloadable p => p.ReloadDataAsync(),
+                _ => Task.CompletedTask,
+            }).ToArray());
         }
 
         static PluginManager()
@@ -86,50 +88,62 @@ namespace Flow.Launcher.Core.Plugin
         /// Call initialize for all plugins
         /// </summary>
         /// <returns>return the list of failed to init plugins or null for none</returns>
-        public static void InitializePlugins(IPublicAPI api)
+        public static async Task InitializePlugins(IPublicAPI api)
         {
             API = api;
             var failedPlugins = new ConcurrentQueue<PluginPair>();
-            Parallel.ForEach(AllPlugins, pair =>
+
+            var InitTasks = AllPlugins.Select(pair => Task.Run(async delegate
             {
                 try
                 {
-                    var milliseconds = Stopwatch.Debug($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>", () =>
+                    var milliseconds = pair.Plugin switch
                     {
-                        pair.Plugin.Init(new PluginInitContext
-                        {
-                            CurrentPluginMetadata = pair.Metadata,
-                            API = API
-                        });
-                    });
+                        IAsyncPlugin plugin
+                            => await Stopwatch.DebugAsync($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>",
+                                                        () => plugin.InitAsync(new PluginInitContext(pair.Metadata, API))),
+                        IPlugin plugin
+                            => Stopwatch.Debug($"|PluginManager.InitializePlugins|Init method time cost for <{pair.Metadata.Name}>",
+                                        () => plugin.Init(new PluginInitContext(pair.Metadata, API))),
+                        _ => throw new ArgumentException(),
+                    };
                     pair.Metadata.InitTime += milliseconds;
-                    Log.Info($"|PluginManager.InitializePlugins|Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
+                    Log.Info(
+                        $"|PluginManager.InitializePlugins|Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
                 }
                 catch (Exception e)
                 {
                     Log.Exception(nameof(PluginManager), $"Fail to Init plugin: {pair.Metadata.Name}", e);
-                    pair.Metadata.Disabled = true; 
+                    pair.Metadata.Disabled = true;
                     failedPlugins.Enqueue(pair);
                 }
-            });
+            }));
+
+            await Task.WhenAll(InitTasks);
 
             _contextMenuPlugins = GetPluginsForInterface<IContextMenu>();
             foreach (var plugin in AllPlugins)
             {
-                if (IsGlobalPlugin(plugin.Metadata))
-                    GlobalPlugins.Add(plugin);
-
-                // Plugins may have multiple ActionKeywords, eg. WebSearch
-                plugin.Metadata.ActionKeywords
-                    .Where(x => x != Query.GlobalPluginWildcardSign)
-                    .ToList()
-                    .ForEach(x => NonGlobalPlugins[x] = plugin);
+                foreach (var actionKeyword in plugin.Metadata.ActionKeywords)
+                {
+                    switch (actionKeyword)
+                    {
+                        case Query.GlobalPluginWildcardSign:
+                            GlobalPlugins.Add(plugin);
+                            break;
+                        default:
+                            NonGlobalPlugins[actionKeyword] = plugin;
+                            break;
+                    }
+                }
             }
 
             if (failedPlugins.Any())
             {
                 var failed = string.Join(",", failedPlugins.Select(x => x.Metadata.Name));
-                API.ShowMsg($"Fail to Init Plugins", $"Plugins: {failed} - fail to load and would be disabled, please contact plugin creator for help", "", false);
+                API.ShowMsg($"Fail to Init Plugins",
+                    $"Plugins: {failed} - fail to load and would be disabled, please contact plugin creator for help",
+                    "", false);
             }
         }
 
@@ -146,24 +160,48 @@ namespace Flow.Launcher.Core.Plugin
             }
         }
 
-        public static List<Result> QueryForPlugin(PluginPair pair, Query query)
+        public static async Task<List<Result>> QueryForPlugin(PluginPair pair, Query query, CancellationToken token)
         {
             var results = new List<Result>();
             try
             {
                 var metadata = pair.Metadata;
-                var milliseconds = Stopwatch.Debug($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}", () =>
+
+                long milliseconds = -1L;
+
+                switch (pair.Plugin)
                 {
-                    results = pair.Plugin.Query(query) ?? new List<Result>();
-                    UpdatePluginMetadata(results, metadata, query);
-                });
+                    case IAsyncPlugin plugin:
+                        milliseconds = await Stopwatch.DebugAsync($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}",
+                            async () => results = await plugin.QueryAsync(query, token).ConfigureAwait(false));
+                        break;
+                    case IPlugin plugin:
+                        await Task.Run(() => milliseconds = Stopwatch.Debug($"|PluginManager.QueryForPlugin|Cost for {metadata.Name}",
+                            () => results = plugin.Query(query)), token).ConfigureAwait(false);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+                token.ThrowIfCancellationRequested();
+                if (results == null)
+                    return results;
+                UpdatePluginMetadata(results, metadata, query);
+
                 metadata.QueryCount += 1;
-                metadata.AvgQueryTime = metadata.QueryCount == 1 ? milliseconds : (metadata.AvgQueryTime + milliseconds) / 2;
+                metadata.AvgQueryTime =
+                    metadata.QueryCount == 1 ? milliseconds : (metadata.AvgQueryTime + milliseconds) / 2;
+                token.ThrowIfCancellationRequested();
+            }
+            catch (OperationCanceledException)
+            {
+                // null will be fine since the results will only be added into queue if the token hasn't been cancelled
+                return results = null;
             }
             catch (Exception e)
             {
                 Log.Exception($"|PluginManager.QueryForPlugin|Exception for plugin <{pair.Metadata.Name}> when query <{query}>", e);
             }
+
             return results;
         }
 
@@ -182,11 +220,6 @@ namespace Flow.Launcher.Core.Plugin
             }
         }
 
-        private static bool IsGlobalPlugin(PluginMetadata metadata)
-        {
-            return metadata.ActionKeywords.Contains(Query.GlobalPluginWildcardSign);
-        }
-
         /// <summary>
         /// get specified plugin, return null if not found
         /// </summary>
@@ -222,16 +255,19 @@ namespace Flow.Launcher.Core.Plugin
                 }
                 catch (Exception e)
                 {
-                    Log.Exception($"|PluginManager.GetContextMenusForPlugin|Can't load context menus for plugin <{pluginPair.Metadata.Name}>", e);
+                    Log.Exception(
+                        $"|PluginManager.GetContextMenusForPlugin|Can't load context menus for plugin <{pluginPair.Metadata.Name}>",
+                        e);
                 }
             }
+
             return results;
         }
 
         public static bool ActionKeywordRegistered(string actionKeyword)
         {
             return actionKeyword != Query.GlobalPluginWildcardSign
-                && NonGlobalPlugins.ContainsKey(actionKeyword);
+                   && NonGlobalPlugins.ContainsKey(actionKeyword);
         }
 
         /// <summary>
@@ -249,6 +285,7 @@ namespace Flow.Launcher.Core.Plugin
             {
                 NonGlobalPlugins[newActionKeyword] = plugin;
             }
+
             plugin.Metadata.ActionKeywords.Add(newActionKeyword);
         }
 
@@ -262,16 +299,16 @@ namespace Flow.Launcher.Core.Plugin
             if (oldActionkeyword == Query.GlobalPluginWildcardSign
                 && // Plugins may have multiple ActionKeywords that are global, eg. WebSearch
                 plugin.Metadata.ActionKeywords
-                                    .Where(x => x == Query.GlobalPluginWildcardSign)
-                                    .ToList()
-                                    .Count == 1)
+                    .Where(x => x == Query.GlobalPluginWildcardSign)
+                    .ToList()
+                    .Count == 1)
             {
                 GlobalPlugins.Remove(plugin);
             }
-            
+
             if (oldActionkeyword != Query.GlobalPluginWildcardSign)
                 NonGlobalPlugins.Remove(oldActionkeyword);
-            
+
 
             plugin.Metadata.ActionKeywords.Remove(oldActionkeyword);
         }

Flow.Launcher.Core/Plugin/PluginsLoader.cs

@@ -37,56 +37,59 @@ namespace Flow.Launcher.Core.Plugin
 
             foreach (var metadata in metadatas)
             {
-                var milliseconds = Stopwatch.Debug($"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
-                {
-
+                var milliseconds = Stopwatch.Debug(
+                    $"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
+                    {
 #if DEBUG
-                    var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
-                    var assembly = assemblyLoader.LoadAssemblyAndDependencies();
-                    var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin));
-                    var plugin = (IPlugin)Activator.CreateInstance(type);
-#else
-                    Assembly assembly = null;
-                    IPlugin plugin = null;
-
-                    try
-                    {
                         var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
-                        assembly = assemblyLoader.LoadAssemblyAndDependencies();
+                        var assembly = assemblyLoader.LoadAssemblyAndDependencies();
+                        var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin),
+                            typeof(IAsyncPlugin));
 
-                        var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin));
+                        var plugin = Activator.CreateInstance(type);
+#else
+                        Assembly assembly = null;
+                        object plugin = null;
 
-                        plugin = (IPlugin)Activator.CreateInstance(type);
-                    }
-                    catch (Exception e) when (assembly == null)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for the plugin: {metadata.Name}", e);
-                    }
-                    catch (InvalidOperationException e)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
-                    }
-                    catch (ReflectionTypeLoadException e)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
-                    }
-                    catch (Exception e)
-                    {
-                        Log.Exception($"|PluginsLoader.DotNetPlugins|The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
-                    }
+                        try
+                        {
+                            var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
+                            assembly = assemblyLoader.LoadAssemblyAndDependencies();
 
-                    if (plugin == null)
-                    {
-                        erroredPlugins.Add(metadata.Name);
-                        return;
-                    }
+                            var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly, typeof(IPlugin), 
+                                typeof(IAsyncPlugin));
+
+                            plugin = Activator.CreateInstance(type);
+                        }
+                        catch (Exception e) when (assembly == null)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for the plugin: {metadata.Name}", e);
+                        }
+                        catch (InvalidOperationException e)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
+                        }
+                        catch (ReflectionTypeLoadException e)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
+                        }
+                        catch (Exception e)
+                        {
+                            Log.Exception($"|PluginsLoader.DotNetPlugins|The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
+                        }
+
+                        if (plugin == null)
+                        {
+                            erroredPlugins.Add(metadata.Name);
+                            return;
+                        }
 #endif
-                    plugins.Add(new PluginPair
-                    {
-                        Plugin = plugin,
-                        Metadata = metadata
+                        plugins.Add(new PluginPair
+                        {
+                            Plugin = plugin,
+                            Metadata = metadata
+                        });
                     });
-                });
                 metadata.InitTime += milliseconds;
             }
 
@@ -95,15 +98,15 @@ namespace Flow.Launcher.Core.Plugin
                 var errorPluginString = String.Join(Environment.NewLine, erroredPlugins);
 
                 var errorMessage = "The following "
-                                    + (erroredPlugins.Count > 1 ? "plugins have " : "plugin has ")
-                                    + "errored and cannot be loaded:";
+                                   + (erroredPlugins.Count > 1 ? "plugins have " : "plugin has ")
+                                   + "errored and cannot be loaded:";
 
                 Task.Run(() =>
                 {
                     MessageBox.Show($"{errorMessage}{Environment.NewLine}{Environment.NewLine}" +
-                                        $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
-                                        $"Please refer to the logs for more information","",
-                                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                                    $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
+                                    $"Please refer to the logs for more information", "",
+                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
                 });
             }
 
@@ -179,6 +182,5 @@ namespace Flow.Launcher.Core.Plugin
                     Metadata = metadata
                 });
         }
-
     }
-}
+}

Flow.Launcher.Core/Updater.cs

@@ -35,7 +35,8 @@ namespace Flow.Launcher.Core
                 UpdateInfo newUpdateInfo;
 
                 if (!silentUpdate)
-                    api.ShowMsg("Please wait...", "Checking for new update");
+                    api.ShowMsg(api.GetTranslation("pleaseWait"),
+                                api.GetTranslation("update_flowlauncher_update_check"));
 
                 using var updateManager = await GitHubUpdateManager(GitHubRepository).ConfigureAwait(false);
 
@@ -51,12 +52,13 @@ namespace Flow.Launcher.Core
                 if (newReleaseVersion <= currentVersion)
                 {
                     if (!silentUpdate)
-                        MessageBox.Show("You already have the latest Flow Launcher version");
+                        MessageBox.Show(api.GetTranslation("update_flowlauncher_already_on_latest"));
                     return;
                 }
 
                 if (!silentUpdate)
-                    api.ShowMsg("Update found", "Updating...");
+                    api.ShowMsg(api.GetTranslation("update_flowlauncher_update_found"),
+                                api.GetTranslation("update_flowlauncher_updating"));
 
                 await updateManager.DownloadReleases(newUpdateInfo.ReleasesToApply).ConfigureAwait(false);
 
@@ -67,8 +69,9 @@ namespace Flow.Launcher.Core
                     var targetDestination = updateManager.RootAppDirectory + $"\\app-{newReleaseVersion.ToString()}\\{DataLocation.PortableFolderName}";
                     FilesFolders.CopyAll(DataLocation.PortableDataPath, targetDestination);
                     if (!FilesFolders.VerifyBothFolderFilesEqual(DataLocation.PortableDataPath, targetDestination))
-                        MessageBox.Show("Flow Launcher was not able to move your user profile data to the new update version. Please manually " +
-                            $"move your profile data folder from {DataLocation.PortableDataPath} to {targetDestination}");
+                        MessageBox.Show(string.Format(api.GetTranslation("update_flowlauncher_fail_moving_portable_user_profile_data"),
+                                                      DataLocation.PortableDataPath,
+                                                      targetDestination));
                 }
                 else
                 {
@@ -79,7 +82,7 @@ namespace Flow.Launcher.Core
 
                 Log.Info($"|Updater.UpdateApp|Update success:{newVersionTips}");
 
-                if (MessageBox.Show(newVersionTips, "New Update", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
+                if (MessageBox.Show(newVersionTips, api.GetTranslation("update_flowlauncher_new_update"), MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                 {
                     UpdateManager.RestartApp(Constant.ApplicationFileName);
                 }
@@ -87,7 +90,8 @@ namespace Flow.Launcher.Core
             catch (Exception e) when (e is HttpRequestException || e is WebException || e is SocketException)
             {
                 Log.Exception($"|Updater.UpdateApp|Check your connection and proxy settings to github-cloud.s3.amazonaws.com.", e);
-                api.ShowMsg("Update Failed", "Check your connection and try updating proxy settings to github-cloud.s3.amazonaws.com.");
+                api.ShowMsg(api.GetTranslation("update_flowlauncher_fail"),
+                            api.GetTranslation("update_flowlauncher_check_connection"));
                 return;
             }
         }

Flow.Launcher.Infrastructure/Flow.Launcher.Infrastructure.csproj

@@ -1,6 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
   <PropertyGroup>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{4FD29318-A8AB-4D8F-AA47-60BC241B8DA3}</ProjectGuid>
     <OutputType>Library</OutputType>
     <UseWpf>true</UseWpf>

Flow.Launcher.Infrastructure/Http/Http.cs

@@ -8,6 +8,7 @@ using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
 using System;
 using System.ComponentModel;
+using System.Threading;
 
 namespace Flow.Launcher.Infrastructure.Http
 {
@@ -15,13 +16,7 @@ namespace Flow.Launcher.Infrastructure.Http
     {
         private const string UserAgent = @"Mozilla/5.0 (Trident/7.0; rv:11.0) like Gecko";
 
-        private static HttpClient client;
-
-        private static SocketsHttpHandler socketsHttpHandler = new SocketsHttpHandler()
-        {
-            UseProxy = true,
-            Proxy = WebProxy
-        };
+        private static HttpClient client = new HttpClient();
 
         static Http()
         {
@@ -31,8 +26,8 @@ namespace Flow.Launcher.Infrastructure.Http
                                                     | SecurityProtocolType.Tls11
                                                     | SecurityProtocolType.Tls12;
 
-            client = new HttpClient(socketsHttpHandler, false);
             client.DefaultRequestHeaders.Add("User-Agent", UserAgent);
+            HttpClient.DefaultProxy = WebProxy;
         }
 
         private static HttpProxy proxy;
@@ -44,6 +39,7 @@ namespace Flow.Launcher.Infrastructure.Http
             {
                 proxy = value;
                 proxy.PropertyChanged += UpdateProxy;
+                UpdateProxy(ProxyProperty.Enabled);
             }
         }
 
@@ -75,11 +71,11 @@ namespace Flow.Launcher.Infrastructure.Http
             };
         }
 
-        public static async Task DownloadAsync([NotNull] string url, [NotNull] string filePath)
+        public static async Task DownloadAsync([NotNull] string url, [NotNull] string filePath, CancellationToken token = default)
         {
             try
             {
-                using var response = await client.GetAsync(url);
+                using var response = await client.GetAsync(url, token);
                 if (response.StatusCode == HttpStatusCode.OK)
                 {
                     await using var fileStream = new FileStream(filePath, FileMode.CreateNew);
@@ -102,40 +98,32 @@ namespace Flow.Launcher.Infrastructure.Http
         /// When supposing the result larger than 83kb, try using GetStreamAsync to avoid reading as string
         /// </summary>
         /// <param name="url"></param>
-        /// <returns></returns>
-        public static Task<string> GetAsync([NotNull] string url)
+        /// <returns>The Http result as string. Null if cancellation requested</returns>
+        public static Task<string> GetAsync([NotNull] string url, CancellationToken token = default)
         {
             Log.Debug($"|Http.Get|Url <{url}>");
-            return GetAsync(new Uri(url.Replace("#", "%23")));
+            return GetAsync(new Uri(url.Replace("#", "%23")), token);
         }
 
         /// <summary>
-        /// Asynchrously get the result as string from url.
-        /// When supposing the result larger than 83kb, try using GetStreamAsync to avoid reading as string
+        /// 
         /// </summary>
         /// <param name="url"></param>
-        /// <returns></returns>
-        public static async Task<string> GetAsync([NotNull] Uri url)
+        /// <param name="token"></param>
+        /// <returns>The Http result as string. Null if cancellation requested</returns>
+        public static async Task<string> GetAsync([NotNull] Uri url, CancellationToken token = default)
         {
             Log.Debug($"|Http.Get|Url <{url}>");
-            try
+            using var response = await client.GetAsync(url, token);
+            var content = await response.Content.ReadAsStringAsync();
+            if (response.StatusCode == HttpStatusCode.OK)
             {
-                using var response = await client.GetAsync(url);
-                var content = await response.Content.ReadAsStringAsync();
-                if (response.StatusCode == HttpStatusCode.OK)
-                {
-                    return content;
-                }
-                else
-                {
-                    throw new HttpRequestException(
-                        $"Error code <{response.StatusCode}> with content <{content}> returned from <{url}>");
-                }
+                return content;
             }
-            catch (HttpRequestException e)
+            else
             {
-                Log.Exception("Infrastructure.Http", "Http Request Error", e, "GetAsync");
-                throw;
+                throw new HttpRequestException(
+                    $"Error code <{response.StatusCode}> with content <{content}> returned from <{url}>");
             }
         }
 
@@ -144,19 +132,11 @@ namespace Flow.Launcher.Infrastructure.Http
         /// </summary>
         /// <param name="url"></param>
         /// <returns></returns>
-        public static async Task<Stream> GetStreamAsync([NotNull] string url)
+        public static async Task<Stream> GetStreamAsync([NotNull] string url, CancellationToken token = default)
         {
-            try
-            {
-                Log.Debug($"|Http.Get|Url <{url}>");
-                var response = await client.GetAsync(url);
-                return await response.Content.ReadAsStreamAsync();
-            }
-            catch (HttpRequestException e)
-            {
-                Log.Exception("Infrastructure.Http", "Http Request Error", e, "GetStreamAsync");
-                throw;
-            }
+            Log.Debug($"|Http.Get|Url <{url}>");
+            var response = await client.GetAsync(url, token);
+            return await response.Content.ReadAsStreamAsync();
         }
     }
 }

Flow.Launcher.Infrastructure/Image/ImageCache.cs

@@ -73,8 +73,7 @@ namespace Flow.Launcher.Infrastructure.Image
 
         public bool ContainsKey(string key)
         {
-            var contains = Data.ContainsKey(key) && Data[key] != null;
-            return contains;
+            return Data.ContainsKey(key) && Data[key].imageSource != null;
         }
 
         public int CacheSize()

Flow.Launcher.Infrastructure/Logger/Log.cs

@@ -50,14 +50,18 @@ namespace Flow.Launcher.Infrastructure.Logger
             return valid;
         }
 
-        
+
 
         [MethodImpl(MethodImplOptions.Synchronized)]
         public static void Exception(string className, string message, System.Exception exception, [CallerMemberName] string methodName = "")
         {
+#if DEBUG
+            throw exception;
+#else
             var classNameWithMethod = CheckClassAndMessageAndReturnFullClassWithMethod(className, message, methodName);
 
             ExceptionInternal(classNameWithMethod, message, exception);
+#endif
         }
 
         private static string CheckClassAndMessageAndReturnFullClassWithMethod(string className, string message,

Flow.Launcher.Infrastructure/PinyinAlphabet.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using JetBrains.Annotations;
@@ -8,14 +9,109 @@ using ToolGood.Words.Pinyin;
 
 namespace Flow.Launcher.Infrastructure
 {
+    public class TranslationMapping
+    {
+        private bool constructed;
+
+        private List<int> originalIndexs = new List<int>();
+        private List<int> translatedIndexs = new List<int>();
+        private int translaedLength = 0;
+
+        public string key { get; private set; }
+
+        public void setKey(string key)
+        {
+            this.key = key;
+        }
+
+        public void AddNewIndex(int originalIndex, int translatedIndex, int length)
+        {
+            if (constructed)
+                throw new InvalidOperationException("Mapping shouldn't be changed after constructed");
+
+            originalIndexs.Add(originalIndex);
+            translatedIndexs.Add(translatedIndex);
+            translatedIndexs.Add(translatedIndex + length);
+            translaedLength += length - 1;
+        }
+
+        public int MapToOriginalIndex(int translatedIndex)
+        {
+            if (translatedIndex > translatedIndexs.Last())
+                return translatedIndex - translaedLength - 1;
+
+            int lowerBound = 0;
+            int upperBound = originalIndexs.Count - 1;
+
+            int count = 0;
+
+            // Corner case handle
+            if (translatedIndex < translatedIndexs[0])
+                return translatedIndex;
+            if (translatedIndex > translatedIndexs.Last())
+            {
+                int indexDef = 0;
+                for (int k = 0; k < originalIndexs.Count; k++)
+                {
+                    indexDef += translatedIndexs[k * 2 + 1] - translatedIndexs[k * 2];
+                }
+
+                return translatedIndex - indexDef - 1;
+            }
+
+            // Binary Search with Range
+            for (int i = originalIndexs.Count / 2;; count++)
+            {
+                if (translatedIndex < translatedIndexs[i * 2])
+                {
+                    // move to lower middle
+                    upperBound = i;
+                    i = (i + lowerBound) / 2;
+                }
+                else if (translatedIndex > translatedIndexs[i * 2 + 1] - 1)
+                {
+                    lowerBound = i;
+                    // move to upper middle
+                    // due to floor of integer division, move one up on corner case
+                    i = (i + upperBound + 1) / 2;
+                }
+                else
+                    return originalIndexs[i];
+
+                if (upperBound - lowerBound <= 1 &&
+                    translatedIndex > translatedIndexs[lowerBound * 2 + 1] &&
+                    translatedIndex < translatedIndexs[upperBound * 2])
+                {
+                    int indexDef = 0;
+                    
+                    for (int j = 0; j < upperBound; j++)
+                    {
+                        indexDef += translatedIndexs[j * 2 + 1] - translatedIndexs[j * 2];
+                    }
+
+                    return translatedIndex - indexDef - 1;
+                }
+            }
+        }
+
+        public void endConstruct()
+        {
+            if (constructed)
+                throw new InvalidOperationException("Mapping has already been constructed");
+            constructed = true;
+        }
+    }
+
     public interface IAlphabet
     {
-        string Translate(string stringToTranslate);
+        public (string translation, TranslationMapping map) Translate(string stringToTranslate);
     }
 
     public class PinyinAlphabet : IAlphabet
     {
-        private ConcurrentDictionary<string, string> _pinyinCache = new ConcurrentDictionary<string, string>();
+        private ConcurrentDictionary<string, (string translation, TranslationMapping map)> _pinyinCache =
+            new ConcurrentDictionary<string, (string translation, TranslationMapping map)>();
+
         private Settings _settings;
 
         public void Initialize([NotNull] Settings settings)
@@ -23,7 +119,7 @@ namespace Flow.Launcher.Infrastructure
             _settings = settings ?? throw new ArgumentNullException(nameof(settings));
         }
 
-        public string Translate(string content)
+        public (string translation, TranslationMapping map) Translate(string content)
         {
             if (_settings.ShouldUsePinyin)
             {
@@ -34,14 +130,7 @@ namespace Flow.Launcher.Infrastructure
                         var resultList = WordsHelper.GetPinyinList(content);
 
                         StringBuilder resultBuilder = new StringBuilder();
-
-                        for (int i = 0; i < resultList.Length; i++)
-                        {
-                            if (content[i] >= 0x3400 && content[i] <= 0x9FD5)
-                                resultBuilder.Append(resultList[i].First());
-                        }
-
-                        resultBuilder.Append(' ');
+                        TranslationMapping map = new TranslationMapping();
 
                         bool pre = false;
 
@@ -49,6 +138,7 @@ namespace Flow.Launcher.Infrastructure
                         {
                             if (content[i] >= 0x3400 && content[i] <= 0x9FD5)
                             {
+                                map.AddNewIndex(i, resultBuilder.Length, resultList[i].Length + 1);
                                 resultBuilder.Append(' ');
                                 resultBuilder.Append(resultList[i]);
                                 pre = true;
@@ -60,15 +150,21 @@ namespace Flow.Launcher.Infrastructure
                                     pre = false;
                                     resultBuilder.Append(' ');
                                 }
+
                                 resultBuilder.Append(resultList[i]);
                             }
                         }
 
-                        return _pinyinCache[content] = resultBuilder.ToString();
+                        map.endConstruct();
+
+                        var key = resultBuilder.ToString();
+                        map.setKey(key);
+
+                        return _pinyinCache[content] = (key, map);
                     }
                     else
                     {
-                        return content;
+                        return (content, null);
                     }
                 }
                 else
@@ -78,7 +174,7 @@ namespace Flow.Launcher.Infrastructure
             }
             else
             {
-                return content;
+                return (content, null);
             }
         }
     }

Flow.Launcher.Infrastructure/Stopwatch.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure.Logger;
 
 namespace Flow.Launcher.Infrastructure
@@ -22,7 +23,22 @@ namespace Flow.Launcher.Infrastructure
             Log.Debug(info);
             return milliseconds;
         }
-
+        
+        /// <summary>
+        /// This stopwatch will appear only in Debug mode
+        /// </summary>
+        public static async Task<long> DebugAsync(string message, Func<Task> action)
+        {
+            var stopWatch = new System.Diagnostics.Stopwatch();
+            stopWatch.Start();
+            await action();
+            stopWatch.Stop();
+            var milliseconds = stopWatch.ElapsedMilliseconds;
+            string info = $"{message} <{milliseconds}ms>";
+            Log.Debug(info);
+            return milliseconds;
+        }
+        
         public static long Normal(string message, Action action)
         {
             var stopWatch = new System.Diagnostics.Stopwatch();
@@ -34,6 +50,20 @@ namespace Flow.Launcher.Infrastructure
             Log.Info(info);
             return milliseconds;
         }
+        
+        public static async Task<long> NormalAsync(string message, Func<Task> action)
+        {
+            var stopWatch = new System.Diagnostics.Stopwatch();
+            stopWatch.Start();
+            await action();
+            stopWatch.Stop();
+            var milliseconds = stopWatch.ElapsedMilliseconds;
+            string info = $"{message} <{milliseconds}ms>";
+            Log.Info(info);
+            return milliseconds;
+        }
+        
+        
 
         public static void StartCount(string name, Action action)
         {

Flow.Launcher.Infrastructure/Storage/JsonStorage.cs

@@ -9,7 +9,7 @@ namespace Flow.Launcher.Infrastructure.Storage
     /// <summary>
     /// Serialize object using json format.
     /// </summary>
-    public class JsonStrorage<T>
+    public class JsonStrorage<T> where T : new()
     {
         private readonly JsonSerializerOptions _serializerSettings;
         private T _data;
@@ -76,7 +76,7 @@ namespace Flow.Launcher.Infrastructure.Storage
                 BackupOriginFile();
             }
 
-            _data = JsonSerializer.Deserialize<T>("{}", _serializerSettings);
+            _data = new T();
             Save();
         }
 

Flow.Launcher.Infrastructure/StringMatcher.cs

@@ -1,8 +1,7 @@
+using Flow.Launcher.Plugin.SharedModels;
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Linq;
-using static Flow.Launcher.Infrastructure.StringMatcher;
 
 namespace Flow.Launcher.Infrastructure
 {
@@ -32,7 +31,20 @@ namespace Flow.Launcher.Infrastructure
         }
 
         /// <summary>
-        /// Current method:
+        /// Current method has two parts, Acronym Match and Fuzzy Search:
+        /// 
+        /// Acronym Match:
+        /// Charater listed below will be considered as acronym
+        /// 1. Character on index 0
+        /// 2. Character appears after a space
+        /// 3. Character that is UpperCase
+        /// 4. Character that is number
+        /// 
+        /// Acronym Match will succeed when all query characters match with acronyms in stringToCompare.
+        /// If any of the characters in the query isn't matched with stringToCompare, Acronym Match will fail.
+        /// Score will be calculated based the percentage of all query characters matched with total acronyms in stringToCompare.
+        /// 
+        /// Fuzzy Search:
         /// Character matching + substring matching;
         /// 1. Query search string is split into substrings, separator is whitespace.
         /// 2. Check each query substring's characters against full compare string,
@@ -44,20 +56,21 @@ namespace Flow.Launcher.Infrastructure
         /// </summary>
         public MatchResult FuzzyMatch(string query, string stringToCompare, MatchOption opt)
         {
-            if (string.IsNullOrEmpty(stringToCompare) || string.IsNullOrEmpty(query)) return new MatchResult (false, UserSettingSearchPrecision);
-            
-            query = query.Trim();
+            if (string.IsNullOrEmpty(stringToCompare) || string.IsNullOrEmpty(query))
+                return new MatchResult(false, UserSettingSearchPrecision);
 
-            if (_alphabet != null)
-            {
-                query = _alphabet.Translate(query);
-                stringToCompare = _alphabet.Translate(stringToCompare);
-            }
+            query = query.Trim();
+            TranslationMapping translationMapping;
+            (stringToCompare, translationMapping) = _alphabet?.Translate(stringToCompare) ?? (stringToCompare, null);
+
+            var currentAcronymQueryIndex = 0;
+            var acronymMatchData = new List<int>();
+            int acronymsTotalCount = 0;
+            int acronymsMatched = 0;
 
             var fullStringToCompareWithoutCase = opt.IgnoreCase ? stringToCompare.ToLower() : stringToCompare;
-
             var queryWithoutCase = opt.IgnoreCase ? query.ToLower() : query;
-                        
+
             var querySubstrings = queryWithoutCase.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
             int currentQuerySubstringIndex = 0;
             var currentQuerySubstring = querySubstrings[currentQuerySubstringIndex];
@@ -75,17 +88,44 @@ namespace Flow.Launcher.Infrastructure
 
             for (var compareStringIndex = 0; compareStringIndex < fullStringToCompareWithoutCase.Length; compareStringIndex++)
             {
+                // If acronyms matching successfully finished, this gets the remaining not matched acronyms for score calculation
+                if (currentAcronymQueryIndex >= query.Length && acronymsMatched == query.Length)
+                {
+                    if (IsAcronymCount(stringToCompare, compareStringIndex))
+                        acronymsTotalCount++;
+                    continue;
+                }
+
+                if (currentAcronymQueryIndex >= query.Length ||
+                    currentAcronymQueryIndex >= query.Length && allQuerySubstringsMatched)
+                    break;
 
                 // To maintain a list of indices which correspond to spaces in the string to compare
                 // To populate the list only for the first query substring
-                if (fullStringToCompareWithoutCase[compareStringIndex].Equals(' ') && currentQuerySubstringIndex == 0)
-                {
+                if (fullStringToCompareWithoutCase[compareStringIndex] == ' ' && currentQuerySubstringIndex == 0)
                     spaceIndices.Add(compareStringIndex);
+
+                // Acronym Match
+                if (IsAcronym(stringToCompare, compareStringIndex))
+                {
+                    if (fullStringToCompareWithoutCase[compareStringIndex] ==
+                        queryWithoutCase[currentAcronymQueryIndex])
+                    {
+                        acronymMatchData.Add(compareStringIndex);
+                        acronymsMatched++;
+
+                        currentAcronymQueryIndex++;
+                    }
                 }
 
-                if (fullStringToCompareWithoutCase[compareStringIndex] != currentQuerySubstring[currentQuerySubstringCharacterIndex])
+                if (IsAcronymCount(stringToCompare, compareStringIndex))
+                    acronymsTotalCount++;
+
+                if (allQuerySubstringsMatched || fullStringToCompareWithoutCase[compareStringIndex] !=
+                    currentQuerySubstring[currentQuerySubstringCharacterIndex])
                 {
                     matchFoundInPreviousLoop = false;
+
                     continue;
                 }
 
@@ -107,14 +147,16 @@ namespace Flow.Launcher.Infrastructure
                     // in order to do so we need to verify all previous chars are part of the pattern
                     var startIndexToVerify = compareStringIndex - currentQuerySubstringCharacterIndex;
 
-                    if (AllPreviousCharsMatched(startIndexToVerify, currentQuerySubstringCharacterIndex, fullStringToCompareWithoutCase, currentQuerySubstring))
+                    if (AllPreviousCharsMatched(startIndexToVerify, currentQuerySubstringCharacterIndex,
+                        fullStringToCompareWithoutCase, currentQuerySubstring))
                     {
                         matchFoundInPreviousLoop = true;
 
                         // if it's the beginning character of the first query substring that is matched then we need to update start index
                         firstMatchIndex = currentQuerySubstringIndex == 0 ? startIndexToVerify : firstMatchIndex;
 
-                        indexList = GetUpdatedIndexList(startIndexToVerify, currentQuerySubstringCharacterIndex, firstMatchIndexInWord, indexList);
+                        indexList = GetUpdatedIndexList(startIndexToVerify, currentQuerySubstringCharacterIndex,
+                            firstMatchIndexInWord, indexList);
                     }
                 }
 
@@ -127,49 +169,96 @@ namespace Flow.Launcher.Infrastructure
                 if (currentQuerySubstringCharacterIndex == currentQuerySubstring.Length)
                 {
                     // if any of the substrings was not matched then consider as all are not matched
-                    allSubstringsContainedInCompareString = matchFoundInPreviousLoop && allSubstringsContainedInCompareString;
+                    allSubstringsContainedInCompareString =
+                        matchFoundInPreviousLoop && allSubstringsContainedInCompareString;
 
                     currentQuerySubstringIndex++;
 
-                    allQuerySubstringsMatched = AllQuerySubstringsMatched(currentQuerySubstringIndex, querySubstrings.Length);
+                    allQuerySubstringsMatched =
+                        AllQuerySubstringsMatched(currentQuerySubstringIndex, querySubstrings.Length);
+
                     if (allQuerySubstringsMatched)
-                        break;
+                        continue;
 
                     // otherwise move to the next query substring
                     currentQuerySubstring = querySubstrings[currentQuerySubstringIndex];
                     currentQuerySubstringCharacterIndex = 0;
                 }
             }
-            
+
+            // return acronym match if all query char matched
+            if (acronymsMatched > 0 && acronymsMatched == query.Length)
+            {
+                int acronymScore = acronymsMatched * 100 / acronymsTotalCount;
+
+                if (acronymScore >= (int)UserSettingSearchPrecision)
+                {
+                    acronymMatchData = acronymMatchData.Select(x => translationMapping?.MapToOriginalIndex(x) ?? x).Distinct().ToList();
+                    return new MatchResult(true, UserSettingSearchPrecision, acronymMatchData, acronymScore);
+                }
+            }
+
             // proceed to calculate score if every char or substring without whitespaces matched
             if (allQuerySubstringsMatched)
             {
                 var nearestSpaceIndex = CalculateClosestSpaceIndex(spaceIndices, firstMatchIndex);
-                var score = CalculateSearchScore(query, stringToCompare, firstMatchIndex - nearestSpaceIndex - 1, lastMatchIndex - firstMatchIndex, allSubstringsContainedInCompareString);
+                var score = CalculateSearchScore(query, stringToCompare, firstMatchIndex - nearestSpaceIndex - 1,
+                    lastMatchIndex - firstMatchIndex, allSubstringsContainedInCompareString);
 
-                return new MatchResult(true, UserSettingSearchPrecision, indexList, score);
+                var resultList = indexList.Select(x => translationMapping?.MapToOriginalIndex(x) ?? x).Distinct().ToList();
+                return new MatchResult(true, UserSettingSearchPrecision, resultList, score);
             }
 
             return new MatchResult(false, UserSettingSearchPrecision);
         }
 
+        private bool IsAcronym(string stringToCompare, int compareStringIndex)
+        {
+            if (IsAcronymChar(stringToCompare, compareStringIndex) || IsAcronymNumber(stringToCompare, compareStringIndex))
+                return true;
+
+            return false;
+        }
+
+        // When counting acronyms, treat a set of numbers as one acronym ie. Visual 2019 as 2 acronyms instead of 5
+        private bool IsAcronymCount(string stringToCompare, int compareStringIndex)
+        {
+            if (IsAcronymChar(stringToCompare, compareStringIndex))
+                return true;
+
+            if (IsAcronymNumber(stringToCompare, compareStringIndex))
+                return compareStringIndex == 0 || char.IsWhiteSpace(stringToCompare[compareStringIndex - 1]);
+
+            return false;
+        }
+
+        private bool IsAcronymChar(string stringToCompare, int compareStringIndex)
+            => char.IsUpper(stringToCompare[compareStringIndex]) ||
+               compareStringIndex == 0 || // 0 index means char is the start of the compare string, which is an acronym
+               char.IsWhiteSpace(stringToCompare[compareStringIndex - 1]);
+
+        private bool IsAcronymNumber(string stringToCompare, int compareStringIndex)
+            => stringToCompare[compareStringIndex] >= 0 && stringToCompare[compareStringIndex] <= 9;
+
         // To get the index of the closest space which preceeds the first matching index
         private int CalculateClosestSpaceIndex(List<int> spaceIndices, int firstMatchIndex)
         {
-            if (spaceIndices.Count == 0)
+            var closestSpaceIndex = -1;
+
+            // spaceIndices should be ordered asc
+            foreach (var index in spaceIndices)
             {
-                return -1;
-            }
-            else
-            {
-                int? ind = spaceIndices.OrderBy(item => (firstMatchIndex - item)).Where(item => firstMatchIndex > item).FirstOrDefault();
-                int closestSpaceIndex = ind ?? -1;
-                return closestSpaceIndex;
+                if (index < firstMatchIndex)
+                    closestSpaceIndex = index;
+                else
+                    break;
             }
+
+            return closestSpaceIndex;
         }
 
         private static bool AllPreviousCharsMatched(int startIndexToVerify, int currentQuerySubstringCharacterIndex,
-                                                        string fullStringToCompareWithoutCase, string currentQuerySubstring)
+            string fullStringToCompareWithoutCase, string currentQuerySubstring)
         {
             var allMatch = true;
             for (int indexToCheck = 0; indexToCheck < currentQuerySubstringCharacterIndex; indexToCheck++)
@@ -183,8 +272,9 @@ namespace Flow.Launcher.Infrastructure
 
             return allMatch;
         }
-        
-        private static List<int> GetUpdatedIndexList(int startIndexToVerify, int currentQuerySubstringCharacterIndex, int firstMatchIndexInWord, List<int> indexList)
+
+        private static List<int> GetUpdatedIndexList(int startIndexToVerify, int currentQuerySubstringCharacterIndex,
+            int firstMatchIndexInWord, List<int> indexList)
         {
             var updatedList = new List<int>();
 
@@ -202,10 +292,12 @@ namespace Flow.Launcher.Infrastructure
 
         private static bool AllQuerySubstringsMatched(int currentQuerySubstringIndex, int querySubstringsLength)
         {
+            // Acronym won't utilize the substring to match
             return currentQuerySubstringIndex >= querySubstringsLength;
         }
 
-        private static int CalculateSearchScore(string query, string stringToCompare, int firstIndex, int matchLen, bool allSubstringsContainedInCompareString)
+        private static int CalculateSearchScore(string query, string stringToCompare, int firstIndex, int matchLen,
+            bool allSubstringsContainedInCompareString)
         {
             // A match found near the beginning of a string is scored more than a match found near the end
             // A match is scored more if the characters in the patterns are closer to each other, 
@@ -239,74 +331,6 @@ namespace Flow.Launcher.Infrastructure
 
             return score;
         }
-
-        public enum SearchPrecisionScore
-        {
-            Regular = 50,
-            Low = 20,
-            None = 0
-        }
-    }
-
-    public class MatchResult
-    {
-        public MatchResult(bool success, SearchPrecisionScore searchPrecision)
-        {
-            Success = success;
-            SearchPrecision = searchPrecision;
-        }
-
-        public MatchResult(bool success, SearchPrecisionScore searchPrecision, List<int> matchData, int rawScore)
-        {
-            Success = success;
-            SearchPrecision = searchPrecision;
-            MatchData = matchData;
-            RawScore = rawScore;
-        }
-
-        public bool Success { get; set; }
-
-        /// <summary>
-        /// The final score of the match result with search precision filters applied.
-        /// </summary>
-        public int Score { get; private set; }
-
-        /// <summary>
-        /// The raw calculated search score without any search precision filtering applied.
-        /// </summary>
-        private int _rawScore;
-
-        public int RawScore
-        {
-            get { return _rawScore; }
-            set
-            {
-                _rawScore = value;
-                Score = ScoreAfterSearchPrecisionFilter(_rawScore);
-            }
-        }
-
-        /// <summary>
-        /// Matched data to highlight.
-        /// </summary>
-        public List<int> MatchData { get; set; }
-
-        public SearchPrecisionScore SearchPrecision { get; set; }
-
-        public bool IsSearchPrecisionScoreMet()
-        {
-            return IsSearchPrecisionScoreMet(_rawScore);
-        }
-
-        private bool IsSearchPrecisionScoreMet(int rawScore)
-        {
-            return rawScore >= (int)SearchPrecision;
-        }
-
-        private int ScoreAfterSearchPrecisionFilter(int rawScore)
-        {
-            return IsSearchPrecisionScoreMet(rawScore) ? rawScore : 0;
-        }
     }
 
     public class MatchOption

Flow.Launcher.Infrastructure/UserSettings/PluginSettings.cs

@@ -31,6 +31,7 @@ namespace Flow.Launcher.Infrastructure.UserSettings
                         metadata.ActionKeyword = settings.ActionKeywords[0];
                     }
                     metadata.Disabled = settings.Disabled;
+                    metadata.Priority = settings.Priority;
                 }
                 else
                 {
@@ -40,7 +41,8 @@ namespace Flow.Launcher.Infrastructure.UserSettings
                         Name = metadata.Name,
                         Version = metadata.Version,
                         ActionKeywords = metadata.ActionKeywords, 
-                        Disabled = metadata.Disabled
+                        Disabled = metadata.Disabled,
+                        Priority = metadata.Priority
                     };
                 }
             }
@@ -52,6 +54,7 @@ namespace Flow.Launcher.Infrastructure.UserSettings
         public string Name { get; set; }
         public string Version { get; set; }
         public List<string> ActionKeywords { get; set; } // a reference of the action keywords from plugin manager
+        public int Priority { get; set; }
 
         /// <summary>
         /// Used only to save the state of the plugin in settings

Flow.Launcher.Infrastructure/UserSettings/Settings.cs

@@ -3,6 +3,7 @@ using System.Collections.ObjectModel;
 using System.Drawing;
 using System.Text.Json.Serialization;
 using Flow.Launcher.Plugin;
+using Flow.Launcher.Plugin.SharedModels;
 
 namespace Flow.Launcher.Infrastructure.UserSettings
 {
@@ -38,7 +39,7 @@ namespace Flow.Launcher.Infrastructure.UserSettings
         /// </summary>
         public bool ShouldUsePinyin { get; set; } = false;
 
-        internal StringMatcher.SearchPrecisionScore QuerySearchPrecision { get; private set; } = StringMatcher.SearchPrecisionScore.Regular;
+        internal SearchPrecisionScore QuerySearchPrecision { get; private set; } = SearchPrecisionScore.Regular;
 
         [JsonIgnore]
         public string QuerySearchPrecisionString
@@ -48,8 +49,8 @@ namespace Flow.Launcher.Infrastructure.UserSettings
             {
                 try
                 {
-                    var precisionScore = (StringMatcher.SearchPrecisionScore)Enum
-                                            .Parse(typeof(StringMatcher.SearchPrecisionScore), value);
+                    var precisionScore = (SearchPrecisionScore)Enum
+                                            .Parse(typeof(SearchPrecisionScore), value);
 
                     QuerySearchPrecision = precisionScore;
                     StringMatcher.Instance.UserSettingSearchPrecision = precisionScore;
@@ -58,8 +59,8 @@ namespace Flow.Launcher.Infrastructure.UserSettings
                 {
                     Logger.Log.Exception(nameof(Settings), "Failed to load QuerySearchPrecisionString value from Settings file", e);
 
-                    QuerySearchPrecision = StringMatcher.SearchPrecisionScore.Regular;
-                    StringMatcher.Instance.UserSettingSearchPrecision = StringMatcher.SearchPrecisionScore.Regular;
+                    QuerySearchPrecision = SearchPrecisionScore.Regular;
+                    StringMatcher.Instance.UserSettingSearchPrecision = SearchPrecisionScore.Regular;
 
                     throw;
                 }

Flow.Launcher.Plugin/Flow.Launcher.Plugin.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
-	
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
   <PropertyGroup>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{8451ECDD-2EA4-4966-BB0A-7BBC40138E80}</ProjectGuid>
     <UseWPF>true</UseWPF>
     <OutputType>Library</OutputType>
@@ -14,10 +14,10 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <Version>1.3.1</Version>
-    <PackageVersion>1.3.1</PackageVersion>
-    <AssemblyVersion>1.3.1</AssemblyVersion>
-    <FileVersion>1.3.1</FileVersion>
+    <Version>1.4.0</Version>
+    <PackageVersion>1.4.0</PackageVersion>
+    <AssemblyVersion>1.4.0</AssemblyVersion>
+    <FileVersion>1.4.0</FileVersion>
     <PackageId>Flow.Launcher.Plugin</PackageId>
     <Authors>Flow-Launcher</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
@@ -64,4 +64,4 @@
     <PackageReference Include="JetBrains.Annotations" Version="2019.1.3" />
   </ItemGroup>
 
-</Project>
+</Project>

Flow.Launcher.Plugin/IAsyncPlugin.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Flow.Launcher.Plugin
+{
+    /// <summary>
+    /// Asynchronous Plugin Model for Flow Launcher
+    /// </summary>
+    public interface IAsyncPlugin
+    {
+        /// <summary>
+        /// Asynchronous Querying
+        /// </summary>
+        /// <para>
+        /// If the Querying or Init method requires high IO transmission
+        /// or performing CPU intense jobs (performing better with cancellation), please use this IAsyncPlugin interface
+        /// </para>
+        /// <param name="query">Query to search</param>
+        /// <param name="token">Cancel when querying job is obsolete</param>
+        /// <returns></returns>
+        Task<List<Result>> QueryAsync(Query query, CancellationToken token);
+
+        /// <summary>
+        /// Initialize plugin asynchrously (will still wait finish to continue)
+        /// </summary>
+        /// <param name="context"></param>
+        /// <returns></returns>
+        Task InitAsync(PluginInitContext context);
+    }
+}

Flow.Launcher.Plugin/IPlugin.cs

@@ -2,9 +2,30 @@
 
 namespace Flow.Launcher.Plugin
 {
+    /// <summary>
+    /// Synchronous Plugin Model for Flow Launcher
+    /// <para>
+    /// If the Querying or Init method requires high IO transmission
+    /// or performaing CPU intense jobs (performing better with cancellation), please try the IAsyncPlugin interface
+    /// </para>
+    /// </summary>
     public interface IPlugin
     {
+        /// <summary>
+        /// Querying when user's search changes
+        /// <para>
+        /// This method will be called within a Task.Run,
+        /// so please avoid synchrously wait for long.
+        /// </para>
+        /// </summary>
+        /// <param name="query">Query to search</param>
+        /// <returns></returns>
         List<Result> Query(Query query);
+
+        /// <summary>
+        /// Initialize plugin
+        /// </summary>
+        /// <param name="context"></param>
         void Init(PluginInitContext context);
     }
-}
+}

Flow.Launcher.Plugin/IPublicAPI.cs

@@ -1,5 +1,10 @@
-using System;
+using Flow.Launcher.Plugin.SharedModels;
+using JetBrains.Annotations;
+using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Plugin
 {
@@ -34,7 +39,7 @@ namespace Flow.Launcher.Plugin
         /// Plugin's in memory data with new content
         /// added by user.
         /// </summary>
-        void ReloadAllPluginData();
+        Task ReloadAllPluginData();
 
         /// <summary>
         /// Check for new Flow Launcher update
@@ -82,5 +87,18 @@ namespace Flow.Launcher.Plugin
         /// if you want to hook something like Ctrl+R, you should use this event
         /// </summary>
         event FlowLauncherGlobalKeyboardEventHandler GlobalKeyboardEvent;
+
+        MatchResult FuzzySearch(string query, string stringToCompare);
+
+        Task<string> HttpGetStringAsync(string url, CancellationToken token = default);
+
+        Task<Stream> HttpGetStreamAsync(string url, CancellationToken token = default);
+
+        Task HttpDownloadAsync([NotNull] string url, [NotNull] string filePath);
+
+        void AddActionKeyword(string pluginId, string newActionKeyword);
+
+        void RemoveActionKeyword(string pluginId, string oldActionKeyword);
+
     }
 }

Flow.Launcher.Plugin/Interfaces/IAsyncReloadable.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+
+namespace Flow.Launcher.Plugin
+{
+    /// <summary>
+    /// This interface is to indicate and allow plugins to asyncronously reload their
+    /// in memory data cache or other mediums when user makes a new change
+    /// that is not immediately captured. For example, for BrowserBookmark and Program
+    /// plugin does not automatically detect when a user added a new bookmark or program,
+    /// so this interface's function is exposed to allow user manually do the reloading after 
+    /// those new additions.
+    /// 
+    /// The command that allows user to manual reload is exposed via Plugin.Sys, and
+    /// it will call the plugins that have implemented this interface.
+    /// </summary>
+    public interface IAsyncReloadable
+    {
+        Task ReloadDataAsync();
+    }
+}

Flow.Launcher.Plugin/Interfaces/IReloadable.cs

@@ -1,7 +1,7 @@
 namespace Flow.Launcher.Plugin
 {
     /// <summary>
-    /// This interface is to indicate and allow plugins to reload their
+    /// This interface is to indicate and allow plugins to synchronously reload their
     /// in memory data cache or other mediums when user makes a new change
     /// that is not immediately captured. For example, for BrowserBookmark and Program
     /// plugin does not automatically detect when a user added a new bookmark or program,
@@ -10,6 +10,10 @@
     /// 
     /// The command that allows user to manual reload is exposed via Plugin.Sys, and
     /// it will call the plugins that have implemented this interface.
+    /// 
+    /// <para>
+    /// If requiring reloading data asynchronously, please use the IAsyncReloadable interface
+    /// </para>
     /// </summary>
     public interface IReloadable
     {

Flow.Launcher.Plugin/PluginInitContext.cs

@@ -4,6 +4,16 @@ namespace Flow.Launcher.Plugin
 {
     public class PluginInitContext
     {
+        public PluginInitContext()
+        {
+        }
+
+        public PluginInitContext(PluginMetadata currentPluginMetadata, IPublicAPI api)
+        {
+            CurrentPluginMetadata = currentPluginMetadata;
+            API = api;
+        }
+
         public PluginMetadata CurrentPluginMetadata { get; internal set; }
 
         /// <summary>

Flow.Launcher.Plugin/PluginMetadata.cs

@@ -36,12 +36,15 @@ namespace Flow.Launcher.Plugin
         public List<string> ActionKeywords { get; set; }
 
         public string IcoPath { get; set;}
-
+        
         public override string ToString()
         {
             return Name;
         }
 
+        [JsonIgnore]
+        public int Priority { get; set; }
+
         /// <summary>
         /// Init time include both plugin load time and init time
         /// </summary>

Flow.Launcher.Plugin/PluginPair.cs

@@ -2,7 +2,7 @@
 {
     public class PluginPair
     {
-        public IPlugin Plugin { get; internal set; }
+        public object Plugin { get; internal set; }
         public PluginMetadata Metadata { get; internal set; }
 
         

Flow.Launcher.Plugin/SharedCommands/FilesFolders.cs

@@ -121,7 +121,7 @@ namespace Flow.Launcher.Plugin.SharedCommands
 
         public static void OpenPath(string fileOrFolderPath)
         {
-            var psi = new ProcessStartInfo { FileName = FileExplorerProgramName, UseShellExecute = true, Arguments = fileOrFolderPath };
+            var psi = new ProcessStartInfo { FileName = FileExplorerProgramName, UseShellExecute = true, Arguments = '"' + fileOrFolderPath + '"' };
             try
             {
                 if (LocationExists(fileOrFolderPath) || FileExists(fileOrFolderPath))
@@ -146,31 +146,23 @@ namespace Flow.Launcher.Plugin.SharedCommands
         /// This checks whether a given string is a directory path or network location string. 
         /// It does not check if location actually exists.
         ///</summary>
-        public static bool IsLocationPathString(string querySearchString)
+        public static bool IsLocationPathString(this string querySearchString)
         {
-            if (string.IsNullOrEmpty(querySearchString))
+            if (string.IsNullOrEmpty(querySearchString) || querySearchString.Length < 3)
                 return false;
 
             // // shared folder location, and not \\\location\
-            if (querySearchString.Length >= 3
-                && querySearchString.StartsWith(@"\\")
-                && char.IsLetter(querySearchString[2]))
+            if (querySearchString.StartsWith(@"\\")
+                && querySearchString[2] != '\\')
                 return true;
 
             // c:\
-            if (querySearchString.Length == 3
-                && char.IsLetter(querySearchString[0])
+            if (char.IsLetter(querySearchString[0])
                 && querySearchString[1] == ':'
                 && querySearchString[2] == '\\')
-                return true;
-
-            // c:\\
-            if (querySearchString.Length >= 4
-                && char.IsLetter(querySearchString[0])
-                && querySearchString[1] == ':'
-                && querySearchString[2] == '\\'
-                && char.IsLetter(querySearchString[3]))
-                return true;
+            {
+                return querySearchString.Length == 3 || querySearchString[3] != '\\';
+            }
 
             return false;
         }

Flow.Launcher.Plugin/SharedModels/MatchResult.cs

@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+
+namespace Flow.Launcher.Plugin.SharedModels
+{
+    public class MatchResult
+    {
+        public MatchResult(bool success, SearchPrecisionScore searchPrecision)
+        {
+            Success = success;
+            SearchPrecision = searchPrecision;
+        }
+
+        public MatchResult(bool success, SearchPrecisionScore searchPrecision, List<int> matchData, int rawScore)
+        {
+            Success = success;
+            SearchPrecision = searchPrecision;
+            MatchData = matchData;
+            RawScore = rawScore;
+        }
+
+        public bool Success { get; set; }
+
+        /// <summary>
+        /// The final score of the match result with search precision filters applied.
+        /// </summary>
+        public int Score { get; private set; }
+
+        /// <summary>
+        /// The raw calculated search score without any search precision filtering applied.
+        /// </summary>
+        private int _rawScore;
+
+        public int RawScore
+        {
+            get { return _rawScore; }
+            set
+            {
+                _rawScore = value;
+                Score = ScoreAfterSearchPrecisionFilter(_rawScore);
+            }
+        }
+
+        /// <summary>
+        /// Matched data to highlight.
+        /// </summary>
+        public List<int> MatchData { get; set; }
+
+        public SearchPrecisionScore SearchPrecision { get; set; }
+
+        public bool IsSearchPrecisionScoreMet()
+        {
+            return IsSearchPrecisionScoreMet(_rawScore);
+        }
+
+        private bool IsSearchPrecisionScoreMet(int rawScore)
+        {
+            return rawScore >= (int)SearchPrecision;
+        }
+
+        private int ScoreAfterSearchPrecisionFilter(int rawScore)
+        {
+            return IsSearchPrecisionScoreMet(rawScore) ? rawScore : 0;
+        }
+    }
+
+    public enum SearchPrecisionScore
+    {
+        Regular = 50,
+        Low = 20,
+        None = 0
+    }
+}

Flow.Launcher.Test/Flow.Launcher.Test.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0-windows10.0.19041.0</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{FF742965-9A80-41A5-B042-D6C7D3A21708}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
@@ -54,6 +54,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
   </ItemGroup>
 
 </Project>

Flow.Launcher.Test/FuzzyMatcherTest.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using NUnit.Framework;
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Plugin;
+using Flow.Launcher.Plugin.SharedModels;
 
 namespace Flow.Launcher.Test
 {
@@ -37,8 +38,8 @@ namespace Flow.Launcher.Test
         {
             var listToReturn = new List<int>();
 
-            Enum.GetValues(typeof(StringMatcher.SearchPrecisionScore))
-                .Cast<StringMatcher.SearchPrecisionScore>()
+            Enum.GetValues(typeof(SearchPrecisionScore))
+                .Cast<SearchPrecisionScore>()
                 .ToList()
                 .ForEach(x => listToReturn.Add((int)x));
 
@@ -92,7 +93,8 @@ namespace Flow.Launcher.Test
         [TestCase("cand")]
         [TestCase("cpywa")]
         [TestCase("ccs")]
-        public void GivenQueryString_WhenAppliedPrecisionFiltering_ThenShouldReturnGreaterThanPrecisionScoreResults(string searchTerm)
+        public void GivenQueryString_WhenAppliedPrecisionFiltering_ThenShouldReturnGreaterThanPrecisionScoreResults(
+            string searchTerm)
         {
             var results = new List<Result>();
             var matcher = new StringMatcher();
@@ -108,9 +110,9 @@ namespace Flow.Launcher.Test
             foreach (var precisionScore in GetPrecisionScores())
             {
                 var filteredResult = results.Where(result => result.Score >= precisionScore)
-                                            .Select(result => result)
-                                            .OrderByDescending(x => x.Score)
-                                            .ToList();
+                    .Select(result => result)
+                    .OrderByDescending(x => x.Score)
+                    .ToList();
 
                 Debug.WriteLine("");
                 Debug.WriteLine("###############################################");
@@ -119,6 +121,7 @@ namespace Flow.Launcher.Test
                 {
                     Debug.WriteLine("SCORE: " + item.Score.ToString() + ", FoundString: " + item.Title);
                 }
+
                 Debug.WriteLine("###############################################");
                 Debug.WriteLine("");
 
@@ -128,37 +131,47 @@ namespace Flow.Launcher.Test
 
         [TestCase(Chrome, Chrome, 157)]
         [TestCase(Chrome, LastIsChrome, 147)]
-        [TestCase(Chrome, HelpCureHopeRaiseOnMindEntityChrome, 25)]
+        [TestCase("chro", HelpCureHopeRaiseOnMindEntityChrome, 50)]
+        [TestCase("chr", HelpCureHopeRaiseOnMindEntityChrome, 30)]
         [TestCase(Chrome, UninstallOrChangeProgramsOnYourComputer, 21)]
         [TestCase(Chrome, CandyCrushSagaFromKing, 0)]
         [TestCase("sql", MicrosoftSqlServerManagementStudio, 110)]
-        [TestCase("sql  manag", MicrosoftSqlServerManagementStudio, 121)]//double spacing intended
+        [TestCase("sql  manag", MicrosoftSqlServerManagementStudio, 121)] //double spacing intended
         public void WhenGivenQueryString_ThenShouldReturn_TheDesiredScoring(
             string queryString, string compareString, int expectedScore)
         {
             // When, Given
-            var matcher = new StringMatcher();
+            var matcher = new StringMatcher {UserSettingSearchPrecision = SearchPrecisionScore.Regular};
             var rawScore = matcher.FuzzyMatch(queryString, compareString).RawScore;
 
             // Should
-            Assert.AreEqual(expectedScore, rawScore, 
+            Assert.AreEqual(expectedScore, rawScore,
                 $"Expected score for compare string '{compareString}': {expectedScore}, Actual: {rawScore}");
         }
 
-        [TestCase("goo", "Google Chrome", StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("chr", "Google Chrome", StringMatcher.SearchPrecisionScore.Low, true)]
-        [TestCase("chr", "Chrome", StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("chr", "Help cure hope raise on mind entity Chrome", StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("chr", "Help cure hope raise on mind entity Chrome", StringMatcher.SearchPrecisionScore.Low, true)]
-        [TestCase("chr", "Candy Crush Saga from King", StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("chr", "Candy Crush Saga from King", StringMatcher.SearchPrecisionScore.None, true)]
-        [TestCase("ccs", "Candy Crush Saga from King", StringMatcher.SearchPrecisionScore.Low, true)]
-        [TestCase("cand", "Candy Crush Saga from King",StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("cand", "Help cure hope raise on mind entity Chrome", StringMatcher.SearchPrecisionScore.Regular, false)]
+        [TestCase("goo", "Google Chrome", SearchPrecisionScore.Regular, true)]
+        [TestCase("chr", "Google Chrome", SearchPrecisionScore.Low, true)]
+        [TestCase("chr", "Chrome", SearchPrecisionScore.Regular, true)]
+        [TestCase("chr", "Help cure hope raise on mind entity Chrome", SearchPrecisionScore.Regular, false)]
+        [TestCase("chr", "Help cure hope raise on mind entity Chrome", SearchPrecisionScore.Low, true)]
+        [TestCase("chr", "Candy Crush Saga from King", SearchPrecisionScore.Regular, false)]
+        [TestCase("chr", "Candy Crush Saga from King", SearchPrecisionScore.None, true)]
+        [TestCase("ccs", "Candy Crush Saga from King", SearchPrecisionScore.Low, true)]
+        [TestCase("cand", "Candy Crush Saga from King", SearchPrecisionScore.Regular, true)]
+        [TestCase("cand", "Help cure hope raise on mind entity Chrome", SearchPrecisionScore.Regular, false)]
+        [TestCase("vsc", VisualStudioCode, SearchPrecisionScore.Regular, true)]
+        [TestCase("vs", VisualStudioCode, SearchPrecisionScore.Regular, true)]
+        [TestCase("vc", VisualStudioCode, SearchPrecisionScore.Regular, true)]
+        [TestCase("vts", VisualStudioCode, SearchPrecisionScore.Regular, false)]
+        [TestCase("vcs", VisualStudioCode, SearchPrecisionScore.Regular, false)]
+        [TestCase("wt", "Windows Terminal From Microsoft Store", SearchPrecisionScore.Regular, false)]
+        [TestCase("vsp", "Visual Studio 2019 Preview", SearchPrecisionScore.Regular, true)]
+        [TestCase("vsp", "2019 Visual Studio Preview", SearchPrecisionScore.Regular, true)]
+        [TestCase("2019p", "Visual Studio 2019 Preview", SearchPrecisionScore.Regular, true)]
         public void WhenGivenDesiredPrecision_ThenShouldReturn_AllResultsGreaterOrEqual(
             string queryString,
             string compareString,
-            StringMatcher.SearchPrecisionScore expectedPrecisionScore,
+            SearchPrecisionScore expectedPrecisionScore,
             bool expectedPrecisionResult)
         {
             // When            
@@ -170,48 +183,50 @@ namespace Flow.Launcher.Test
             Debug.WriteLine("");
             Debug.WriteLine("###############################################");
             Debug.WriteLine($"QueryString: {queryString}     CompareString: {compareString}");
-            Debug.WriteLine($"RAW SCORE: {matchResult.RawScore.ToString()}, PrecisionLevelSetAt: {expectedPrecisionScore} ({(int)expectedPrecisionScore})");
+            Debug.WriteLine(
+                $"RAW SCORE: {matchResult.RawScore.ToString()}, PrecisionLevelSetAt: {expectedPrecisionScore} ({(int) expectedPrecisionScore})");
             Debug.WriteLine("###############################################");
             Debug.WriteLine("");
 
             // Should
             Assert.AreEqual(expectedPrecisionResult, matchResult.IsSearchPrecisionScoreMet(),
-                $"Query:{queryString}{Environment.NewLine} " +
-                $"Compare:{compareString}{Environment.NewLine}" +
+                $"Query: {queryString}{Environment.NewLine} " +
+                $"Compare: {compareString}{Environment.NewLine}" +
                 $"Raw Score: {matchResult.RawScore}{Environment.NewLine}" +
                 $"Precision Score: {(int)expectedPrecisionScore}");
         }
 
-        [TestCase("exce", "OverLeaf-Latex: An online LaTeX editor", StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("term", "Windows Terminal (Preview)", StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("sql s managa", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("sql' s manag", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("sql s manag", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("sql manag", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("sql", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("sql serv", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("servez", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("sql servz", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("sql serv man", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("sql studio", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("mic", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("chr", "Shutdown", StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("mssms", MicrosoftSqlServerManagementStudio, StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("chr", "Change settings for text-to-speech and for speech recognition (if installed).", StringMatcher.SearchPrecisionScore.Regular, false)]
-        [TestCase("ch r", "Change settings for text-to-speech and for speech recognition (if installed).", StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("a test", "This is a test", StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("test", "This is a test", StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("cod", VisualStudioCode, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("code", VisualStudioCode, StringMatcher.SearchPrecisionScore.Regular, true)]
-        [TestCase("codes", "Visual Studio Codes", StringMatcher.SearchPrecisionScore.Regular, true)]
+        [TestCase("exce", "OverLeaf-Latex: An online LaTeX editor", SearchPrecisionScore.Regular, false)]
+        [TestCase("term", "Windows Terminal (Preview)", SearchPrecisionScore.Regular, true)]
+        [TestCase("sql s managa", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, false)]
+        [TestCase("sql' s manag", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, false)]
+        [TestCase("sql s manag", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("sql manag", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("sql", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("sql serv", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("servez", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, false)]
+        [TestCase("sql servz", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, false)]
+        [TestCase("sql serv man", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("sql studio", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("mic", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("mssms", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("msms", MicrosoftSqlServerManagementStudio, SearchPrecisionScore.Regular, true)]
+        [TestCase("chr", "Shutdown", SearchPrecisionScore.Regular, false)]
+        [TestCase("chr", "Change settings for text-to-speech and for speech recognition (if installed).", SearchPrecisionScore.Regular, false)]
+        [TestCase("ch r", "Change settings for text-to-speech and for speech recognition (if installed).", SearchPrecisionScore.Regular, true)]
+        [TestCase("a test", "This is a test", SearchPrecisionScore.Regular, true)]
+        [TestCase("test", "This is a test", SearchPrecisionScore.Regular, true)]
+        [TestCase("cod", VisualStudioCode, SearchPrecisionScore.Regular, true)]
+        [TestCase("code", VisualStudioCode, SearchPrecisionScore.Regular, true)]
+        [TestCase("codes", "Visual Studio Codes", SearchPrecisionScore.Regular, true)]
         public void WhenGivenQuery_ShouldReturnResults_ContainingAllQuerySubstrings(
             string queryString,
             string compareString,
-            StringMatcher.SearchPrecisionScore expectedPrecisionScore,
+            SearchPrecisionScore expectedPrecisionScore,
             bool expectedPrecisionResult)
         {
             // When
-            var matcher = new StringMatcher { UserSettingSearchPrecision = expectedPrecisionScore };
+            var matcher = new StringMatcher {UserSettingSearchPrecision = expectedPrecisionScore};
 
             // Given
             var matchResult = matcher.FuzzyMatch(queryString, compareString);
@@ -219,7 +234,8 @@ namespace Flow.Launcher.Test
             Debug.WriteLine("");
             Debug.WriteLine("###############################################");
             Debug.WriteLine($"QueryString: {queryString}     CompareString: {compareString}");
-            Debug.WriteLine($"RAW SCORE: {matchResult.RawScore.ToString()}, PrecisionLevelSetAt: {expectedPrecisionScore} ({(int)expectedPrecisionScore})");
+            Debug.WriteLine(
+                $"RAW SCORE: {matchResult.RawScore.ToString()}, PrecisionLevelSetAt: {expectedPrecisionScore} ({(int) expectedPrecisionScore})");
             Debug.WriteLine("###############################################");
             Debug.WriteLine("");
 
@@ -238,7 +254,7 @@ namespace Flow.Launcher.Test
             string queryString, string compareString1, string compareString2)
         {
             // When
-            var matcher = new StringMatcher { UserSettingSearchPrecision = StringMatcher.SearchPrecisionScore.Regular };
+            var matcher = new StringMatcher {UserSettingSearchPrecision = SearchPrecisionScore.Regular};
 
             // Given
             var compareString1Result = matcher.FuzzyMatch(queryString, compareString1);
@@ -247,8 +263,10 @@ namespace Flow.Launcher.Test
             Debug.WriteLine("");
             Debug.WriteLine("###############################################");
             Debug.WriteLine($"QueryString: \"{queryString}\"{Environment.NewLine}");
-            Debug.WriteLine($"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}");
-            Debug.WriteLine($"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
+            Debug.WriteLine(
+                $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}");
+            Debug.WriteLine(
+                $"CompareString2: \"{compareString2}\", Score: {compareString2Result.Score}{Environment.NewLine}");
             Debug.WriteLine("###############################################");
             Debug.WriteLine("");
 
@@ -256,13 +274,13 @@ namespace Flow.Launcher.Test
             Assert.True(compareString1Result.Score > compareString2Result.Score,
                 $"Query: \"{queryString}\"{Environment.NewLine} " +
                 $"CompareString1: \"{compareString1}\", Score: {compareString1Result.Score}{Environment.NewLine}" +
-                $"Should be greater than{ Environment.NewLine}" +
+                $"Should be greater than{Environment.NewLine}" +
                 $"CompareString2: \"{compareString2}\", Score: {compareString1Result.Score}{Environment.NewLine}");
         }
 
         [TestCase("vim", "Vim", "ignoreDescription", "ignore.exe", "Vim Diff", "ignoreDescription", "ignore.exe")]
         public void WhenMultipleResults_ExactMatchingResult_ShouldHaveGreatestScore(
-            string queryString, string firstName, string firstDescription, string firstExecutableName, 
+            string queryString, string firstName, string firstDescription, string firstExecutableName,
             string secondName, string secondDescription, string secondExecutableName)
         {
             // Act
@@ -275,15 +293,39 @@ namespace Flow.Launcher.Test
             var secondDescriptionMatch = matcher.FuzzyMatch(queryString, secondDescription).RawScore;
             var secondExecutableNameMatch = matcher.FuzzyMatch(queryString, secondExecutableName).RawScore;
 
-            var firstScore = new[] { firstNameMatch, firstDescriptionMatch, firstExecutableNameMatch }.Max();
-            var secondScore = new[] { secondNameMatch, secondDescriptionMatch, secondExecutableNameMatch }.Max();
+            var firstScore = new[] {firstNameMatch, firstDescriptionMatch, firstExecutableNameMatch}.Max();
+            var secondScore = new[] {secondNameMatch, secondDescriptionMatch, secondExecutableNameMatch}.Max();
 
             // Assert
             Assert.IsTrue(firstScore > secondScore,
                 $"Query: \"{queryString}\"{Environment.NewLine} " +
                 $"Name of first: \"{firstName}\", Final Score: {firstScore}{Environment.NewLine}" +
-                $"Should be greater than{ Environment.NewLine}" +
+                $"Should be greater than{Environment.NewLine}" +
                 $"Name of second: \"{secondName}\", Final Score: {secondScore}{Environment.NewLine}");
         }
+
+        [TestCase("vsc", "Visual Studio Code", 100)]
+        [TestCase("jbr", "JetBrain Rider", 100)]
+        [TestCase("jr", "JetBrain Rider", 66)]
+        [TestCase("vs", "Visual Studio", 100)]
+        [TestCase("vs", "Visual Studio Preview", 66)]
+        [TestCase("vsp", "Visual Studio Preview", 100)]
+        [TestCase("pc", "postman canary", 100)]
+        [TestCase("psc", "Postman super canary", 100)]
+        [TestCase("psc", "Postman super Canary", 100)]
+        [TestCase("vsp", "Visual Studio", 0)]
+        [TestCase("vps", "Visual Studio", 0)]
+        [TestCase(Chrome, HelpCureHopeRaiseOnMindEntityChrome, 75)]
+        public void WhenGivenAnAcronymQuery_ShouldReturnAcronymScore(string queryString, string compareString,
+            int desiredScore)
+        {
+            var matcher = new StringMatcher();
+            var score = matcher.FuzzyMatch(queryString, compareString).Score;
+            Assert.IsTrue(score == desiredScore,
+                $@"Query: ""{queryString}""
+                   CompareString: ""{compareString}""
+                   Score: {score}
+                   Desired Score: {desiredScore}");
+        }
     }
-}
+}

Flow.Launcher.Test/Plugins/ExplorerTest.cs

@@ -7,6 +7,8 @@ using Flow.Launcher.Plugin.SharedCommands;
 using NUnit.Framework;
 using System;
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Test.Plugins
 {
@@ -17,15 +19,15 @@ namespace Flow.Launcher.Test.Plugins
     [TestFixture]
     public class ExplorerTest
     {
-        private List<Result> MethodWindowsIndexSearchReturnsZeroResults(Query dummyQuery, string dummyString)
+        private async Task<List<Result>> MethodWindowsIndexSearchReturnsZeroResultsAsync(Query dummyQuery, string dummyString, CancellationToken dummyToken)
         {
             return new List<Result>();
         }
 
-        private List<Result> MethodDirectoryInfoClassSearchReturnsTwoResults(Query dummyQuery, string dummyString)
+        private List<Result> MethodDirectoryInfoClassSearchReturnsTwoResults(Query dummyQuery, string dummyString, CancellationToken token)
         {
-            return new List<Result> 
-            { 
+            return new List<Result>
+            {
                 new Result
                 {
                     Title="Result 1"
@@ -58,16 +60,16 @@ namespace Flow.Launcher.Test.Plugins
                 $"Actual: {result}{Environment.NewLine}");
         }
 
-        [TestCase("C:\\", "SELECT TOP 100 System.FileName, System.ItemUrl, System.ItemType FROM SystemIndex WHERE directory='file:C:\\'")]
-        [TestCase("C:\\SomeFolder\\", "SELECT TOP 100 System.FileName, System.ItemUrl, System.ItemType FROM SystemIndex WHERE directory='file:C:\\SomeFolder\\'")]
+        [TestCase("C:\\", "SELECT TOP 100 System.FileName, System.ItemUrl, System.ItemType FROM SystemIndex WHERE directory='file:C:\\' ORDER BY System.FileName")]
+        [TestCase("C:\\SomeFolder\\", "SELECT TOP 100 System.FileName, System.ItemUrl, System.ItemType FROM SystemIndex WHERE directory='file:C:\\SomeFolder\\' ORDER BY System.FileName")]
         public void GivenWindowsIndexSearch_WhenSearchTypeIsTopLevelDirectorySearch_ThenQueryShouldUseExpectedString(string folderPath, string expectedString)
         {
             // Given
             var queryConstructor = new QueryConstructor(new Settings());
-            
+
             //When            
             var queryString = queryConstructor.QueryForTopLevelDirectorySearch(folderPath);
-            
+
             // Then
             Assert.IsTrue(queryString == expectedString,
                 $"Expected string: {expectedString}{Environment.NewLine} " +
@@ -77,7 +79,7 @@ namespace Flow.Launcher.Test.Plugins
         [TestCase("C:\\SomeFolder\\flow.launcher.sln", "SELECT TOP 100 System.FileName, System.ItemUrl, System.ItemType " +
             "FROM SystemIndex WHERE (System.FileName LIKE 'flow.launcher.sln%' " +
                                         "OR CONTAINS(System.FileName,'\"flow.launcher.sln*\"',1033))" +
-                                        " AND directory='file:C:\\SomeFolder'")]
+                                        " AND directory='file:C:\\SomeFolder' ORDER BY System.FileName")]
         public void GivenWindowsIndexSearchTopLevelDirectory_WhenSearchingForSpecificItem_ThenQueryShouldUseExpectedString(
             string userSearchString, string expectedString)
         {
@@ -112,13 +114,10 @@ namespace Flow.Launcher.Test.Plugins
         }
 
         [TestCase("scope='file:'")]
-        public void GivenWindowsIndexSearch_WhenSearchAllFoldersAndFiles_ThenQueryWhereRestrictionsShouldUseScopeString(string expectedString) 
+        public void GivenWindowsIndexSearch_WhenSearchAllFoldersAndFiles_ThenQueryWhereRestrictionsShouldUseScopeString(string expectedString)
         {
-            // Given
-            var queryConstructor = new QueryConstructor(new Settings());
-
             //When
-            var resultString = queryConstructor.QueryWhereRestrictionsForAllFilesAndFoldersSearch();
+            var resultString = QueryConstructor.QueryWhereRestrictionsForAllFilesAndFoldersSearch;
 
             // Then
             Assert.IsTrue(resultString == expectedString,
@@ -128,9 +127,9 @@ namespace Flow.Launcher.Test.Plugins
 
         [TestCase("flow.launcher.sln", "SELECT TOP 100 \"System.FileName\", \"System.ItemUrl\", \"System.ItemType\" " +
             "FROM \"SystemIndex\" WHERE (System.FileName LIKE 'flow.launcher.sln%' " +
-                                        "OR CONTAINS(System.FileName,'\"flow.launcher.sln*\"',1033)) AND scope='file:'")]
+                                        "OR CONTAINS(System.FileName,'\"flow.launcher.sln*\"',1033)) AND scope='file:' ORDER BY System.FileName")]
         public void GivenWindowsIndexSearch_WhenSearchAllFoldersAndFiles_ThenQueryShouldUseExpectedString(
-            string userSearchString, string expectedString) 
+            string userSearchString, string expectedString)
         {
             // Given
             var queryConstructor = new QueryConstructor(new Settings());
@@ -145,18 +144,19 @@ namespace Flow.Launcher.Test.Plugins
         }
 
         [TestCase]
-        public void GivenTopLevelDirectorySearch_WhenIndexSearchNotRequired_ThenSearchMethodShouldContinueDirectoryInfoClassSearch() 
+        public async Task GivenTopLevelDirectorySearch_WhenIndexSearchNotRequired_ThenSearchMethodShouldContinueDirectoryInfoClassSearch()
         {
             // Given
             var searchManager = new SearchManager(new Settings(), new PluginInitContext());
-            
+
             // When
-            var results = searchManager.TopLevelDirectorySearchBehaviour(
-                                            MethodWindowsIndexSearchReturnsZeroResults, 
-                                            MethodDirectoryInfoClassSearchReturnsTwoResults, 
-                                            false, 
+            var results = await searchManager.TopLevelDirectorySearchBehaviourAsync(
+                                            MethodWindowsIndexSearchReturnsZeroResultsAsync,
+                                            MethodDirectoryInfoClassSearchReturnsTwoResults,
+                                            false,
                                             new Query(),
-                                            "string not used");
+                                            "string not used",
+                                            default);
 
             // Then
             Assert.IsTrue(results.Count == 2,
@@ -165,18 +165,19 @@ namespace Flow.Launcher.Test.Plugins
         }
 
         [TestCase]
-        public void GivenTopLevelDirectorySearch_WhenIndexSearchNotRequired_ThenSearchMethodShouldNotContinueDirectoryInfoClassSearch()
+        public async Task GivenTopLevelDirectorySearch_WhenIndexSearchNotRequired_ThenSearchMethodShouldNotContinueDirectoryInfoClassSearch()
         {
             // Given
             var searchManager = new SearchManager(new Settings(), new PluginInitContext());
 
             // When
-            var results = searchManager.TopLevelDirectorySearchBehaviour(
-                                            MethodWindowsIndexSearchReturnsZeroResults,
+            var results = await searchManager.TopLevelDirectorySearchBehaviourAsync(
+                                            MethodWindowsIndexSearchReturnsZeroResultsAsync,
                                             MethodDirectoryInfoClassSearchReturnsTwoResults,
                                             true,
                                             new Query(),
-                                            "string not used");
+                                            "string not used",
+                                            default);
 
             // Then
             Assert.IsTrue(results.Count == 0,
@@ -201,7 +202,7 @@ namespace Flow.Launcher.Test.Plugins
         }
 
         [TestCase("some words", "SELECT TOP 100 System.FileName, System.ItemUrl, System.ItemType " +
-                    "FROM SystemIndex WHERE FREETEXT('some words') AND scope='file:'")]
+                    "FROM SystemIndex WHERE FREETEXT('some words') AND scope='file:' ORDER BY System.FileName")]
         public void GivenWindowsIndexSearch_WhenSearchForFileContent_ThenQueryShouldUseExpectedString(
             string userSearchString, string expectedString)
         {
@@ -223,7 +224,7 @@ namespace Flow.Launcher.Test.Plugins
             var query = new Query { ActionKeyword = "doc:", Search = "search term" };
 
             var searchManager = new SearchManager(new Settings(), new PluginInitContext());
-            
+
             // When
             var result = searchManager.IsFileContentSearch(query.ActionKeyword);
 
@@ -239,6 +240,9 @@ namespace Flow.Launcher.Test.Plugins
         [TestCase(@"cc:\", false)]
         [TestCase(@"\\\SomeNetworkLocation\", false)]
         [TestCase("RandomFile", false)]
+        [TestCase(@"c:\>*", true)]
+        [TestCase(@"c:\>", true)]
+        [TestCase(@"c:\SomeLocation\SomeOtherLocation\>", true)]
         public void WhenGivenQuerySearchString_ThenShouldIndicateIfIsLocationPathString(string querySearchString, bool expectedResult)
         {
             // When, Given
@@ -250,7 +254,7 @@ namespace Flow.Launcher.Test.Plugins
                 $"Actual check result is {result} {Environment.NewLine}");
 
         }
-        
+
         [TestCase(@"C:\SomeFolder\SomeApp", true, @"C:\SomeFolder\")]
         [TestCase(@"C:\SomeFolder\SomeApp\SomeFile", true, @"C:\SomeFolder\SomeApp\")]
         [TestCase(@"C:\NonExistentFolder\SomeApp", false, "")]
@@ -291,10 +295,10 @@ namespace Flow.Launcher.Test.Plugins
         }
 
         [TestCase("c:\\SomeFolder\\>", "scope='file:c:\\SomeFolder'")]
-        [TestCase("c:\\SomeFolder\\>SomeName", "(System.FileName LIKE 'SomeName%' " +
-                                                        "OR CONTAINS(System.FileName,'\"SomeName*\"',1033)) AND " +
-                                                        "scope='file:c:\\SomeFolder'")]
-        public void GivenWindowsIndexSearch_WhenSearchPatternHotKeyIsSearchAll_ThenQueryWhereRestrictionsShouldUseScopeString(string path, string expectedString) 
+        [TestCase("c:\\SomeFolder\\>SomeName", "(System.FileName LIKE 'SomeName%' "
+                                               + "OR CONTAINS(System.FileName,'\"SomeName*\"',1033)) AND "
+                                               + "scope='file:c:\\SomeFolder'")]
+        public void GivenWindowsIndexSearch_WhenSearchPatternHotKeyIsSearchAll_ThenQueryWhereRestrictionsShouldUseScopeString(string path, string expectedString)
         {
             // Given
             var queryConstructor = new QueryConstructor(new Settings());
@@ -308,16 +312,14 @@ namespace Flow.Launcher.Test.Plugins
                 $"Actual string was: {resultString}{Environment.NewLine}");
         }
 
-        [TestCase("c:\\somefolder\\>somefile","*somefile*")]
+        [TestCase("c:\\somefolder\\>somefile", "*somefile*")]
         [TestCase("c:\\somefolder\\somefile", "somefile*")]
         [TestCase("c:\\somefolder\\", "*")]
         public void GivenDirectoryInfoSearch_WhenSearchPatternHotKeyIsSearchAll_ThenSearchCriteriaShouldUseCriteriaString(string path, string expectedString)
         {
-            // Given
-            var criteriaConstructor = new DirectoryInfoSearch(new PluginInitContext());
 
             //When
-            var resultString = criteriaConstructor.ConstructSearchCriteria(path);
+            var resultString = DirectoryInfoSearch.ConstructSearchCriteria(path);
 
             // Then
             Assert.IsTrue(resultString == expectedString,

Flow.Launcher/App.xaml

@@ -3,7 +3,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:ui="http://schemas.modernwpf.com/2019"
              ShutdownMode="OnMainWindowClose"
-             Startup="OnStartup">
+             Startup="OnStartupAsync">
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>

Flow.Launcher/App.xaml.cs

@@ -45,9 +45,9 @@ namespace Flow.Launcher
             }
         }
 
-        private void OnStartup(object sender, StartupEventArgs e)
+        private async void OnStartupAsync(object sender, StartupEventArgs e)
         {
-            Stopwatch.Normal("|App.OnStartup|Startup cost", () =>
+            await Stopwatch.NormalAsync("|App.OnStartup|Startup cost", async () =>
             {
                 _portable.PreStartCleanUpAfterPortabilityUpdate();
 
@@ -61,6 +61,8 @@ namespace Flow.Launcher
                 _settingsVM = new SettingWindowViewModel(_updater, _portable);
                 _settings = _settingsVM.Settings;
 
+                Http.Proxy = _settings.Proxy;
+
                 _alphabet.Initialize(_settings);
                 _stringMatcher = new StringMatcher(_alphabet);
                 StringMatcher.Instance = _stringMatcher;
@@ -68,9 +70,10 @@ namespace Flow.Launcher
 
                 PluginManager.LoadPlugins(_settings.PluginSettings);
                 _mainVM = new MainViewModel(_settings);
-                var window = new MainWindow(_settings, _mainVM);
                 API = new PublicAPIInstance(_settingsVM, _mainVM, _alphabet);
-                PluginManager.InitializePlugins(API);
+                await PluginManager.InitializePlugins(API);
+                var window = new MainWindow(_settings, _mainVM);
+
                 Log.Info($"|App.OnStartup|Dependencies Info:{ErrorReporting.DependenciesInfo()}");
 
                 Current.MainWindow = window;
@@ -84,8 +87,6 @@ namespace Flow.Launcher
                 ThemeManager.Instance.Settings = _settings;
                 ThemeManager.Instance.ChangeTheme(_settings.Theme);
 
-                Http.Proxy = _settings.Proxy;
-
                 Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
 
                 RegisterExitEvents();

Flow.Launcher/CustomQueryHotkeySetting.xaml

@@ -5,7 +5,7 @@
         Icon="Images\app.png"
         ResizeMode="NoResize"
         WindowStartupLocation="CenterScreen"
-        Title="Custom Plugin Hotkey" Height="200" Width="674.766">
+        Title="{DynamicResource customeQueryHotkeyTitle}" Height="200" Width="674.766">
     <Window.InputBindings>
         <KeyBinding Key="Escape" Command="Close"/>
     </Window.InputBindings>

Flow.Launcher/Flow.Launcher.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
   
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFramework>net5.0-windows10.0.19041.0</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
     <StartupObject>Flow.Launcher.App</StartupObject>
@@ -63,6 +63,9 @@
     <Content Include="Images\*.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Images\*.svg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
 
   <ItemGroup>
@@ -75,7 +78,7 @@
 
   <ItemGroup>
     <PackageReference Include="InputSimulator" Version="1.0.4" />
-    <PackageReference Include="ModernWpfUI" Version="0.9.2" />
+    <PackageReference Include="ModernWpfUI" Version="0.8.3" />
     <PackageReference Include="NHotkey.Wpf" Version="1.2.1" />
     <PackageReference Include="NuGet.CommandLine" Version="5.4.0">
       <PrivateAssets>all</PrivateAssets>

Flow.Launcher/Languages/en.xaml

@@ -17,6 +17,7 @@
     <!--Setting General-->
     <system:String x:Key="flowlauncher_settings">Flow Launcher Settings</system:String>
     <system:String x:Key="general">General</system:String>
+    <system:String x:Key="portableMode">Portable Mode</system:String>
     <system:String x:Key="startFlowLauncherOnSystemStartup">Start Flow Launcher on system startup</system:String>
     <system:String x:Key="hideFlowLauncherWhenLoseFocus">Hide Flow Launcher when focus is lost</system:String>
     <system:String x:Key="dontPromptUpdateMsg">Do not show new version notifications</system:String>
@@ -39,10 +40,13 @@
     <!--Setting Plugin-->
     <system:String x:Key="plugin">Plugin</system:String>
     <system:String x:Key="browserMorePlugins">Find more plugins</system:String>
+    <system:String x:Key="enable">Enable</system:String>
     <system:String x:Key="disable">Disable</system:String>
     <system:String x:Key="actionKeywords">Action keyword:</system:String>
     <system:String x:Key="currentActionKeywords">Current action keyword:</system:String>
     <system:String x:Key="newActionKeyword">New action keyword:</system:String>
+    <system:String x:Key="currentPriority">Current Priority:</system:String>
+    <system:String x:Key="newPriority">New Priority:</system:String>
     <system:String x:Key="pluginDirectory">Plugin Directory</system:String>
     <system:String x:Key="author">Author</system:String>
     <system:String x:Key="plugin_init_time">Init time:</system:String>
@@ -104,6 +108,10 @@
     </system:String>
     <system:String x:Key="releaseNotes">Release Notes</system:String>
 
+    <!--Priority Setting Dialog-->
+    <system:String x:Key="priority_tips">Greater the number, the higher the result will be ranked. Try setting it as 5. If you want the results to be lower than any other plugin's, provide a negative number</system:String>
+    <system:String x:Key="invalidPriority">Please provide an valid integer for Priority!</system:String>
+
     <!--Action Keyword Setting Dialog-->
     <system:String x:Key="oldActionKeywords">Old Action Keyword</system:String>
     <system:String x:Key="newActionKeywords">New Action Keyword</system:String>
@@ -116,6 +124,7 @@
     <system:String x:Key="actionkeyword_tips">Use * if you don't want to specify an action keyword</system:String>
 
     <!--Custom Query Hotkey Dialog-->
+    <system:String x:Key="customeQueryHotkeyTitle">Custom Plugin Hotkey</system:String>
     <system:String x:Key="preview">Preview</system:String>
     <system:String x:Key="hotkeyIsNotUnavailable">Hotkey is unavailable, please select a new hotkey</system:String>
     <system:String x:Key="invalidPluginHotkey">Invalid plugin hotkey</system:String>
@@ -140,11 +149,23 @@
     <system:String x:Key="reportWindow_report_failed">Failed to send report</system:String>
     <system:String x:Key="reportWindow_flowlauncher_got_an_error">Flow Launcher got an error</system:String>
 
+    <!--General Notice-->
+    <system:String x:Key="pleaseWait">Please wait...</system:String>
+
     <!--update-->
+    <system:String x:Key="update_flowlauncher_update_check">Checking for new update</system:String>
+    <system:String x:Key="update_flowlauncher_already_on_latest">You already have the latest Flow Launcher version</system:String>
+    <system:String x:Key="update_flowlauncher_update_found">Update found</system:String>
+    <system:String x:Key="update_flowlauncher_updating">Updating...</system:String>
+    <system:String x:Key="update_flowlauncher_fail_moving_portable_user_profile_data">Flow Launcher was not able to move your user profile data to the new update version.
+        Please manually move your profile data folder from {0} to {1}</system:String>
+    <system:String x:Key="update_flowlauncher_new_update">New Update</system:String>
     <system:String x:Key="update_flowlauncher_update_new_version_available">New Flow Launcher release {0} is now available</system:String>
     <system:String x:Key="update_flowlauncher_update_error">An error occurred while trying to install software updates</system:String>
     <system:String x:Key="update_flowlauncher_update">Update</system:String>
     <system:String x:Key="update_flowlauncher_update_cancel">Cancel</system:String>
+    <system:String x:Key="update_flowlauncher_fail">Update Failed</system:String>
+    <system:String x:Key="update_flowlauncher_check_connection">Check your connection and try updating proxy settings to github-cloud.s3.amazonaws.com.</system:String>
     <system:String x:Key="update_flowlauncher_update_restart_flowlauncher_tip">This upgrade will restart Flow Launcher</system:String>
     <system:String x:Key="update_flowlauncher_update_upadte_files">Following files will be updated</system:String>
     <system:String x:Key="update_flowlauncher_update_files">Update files</system:String>

Flow.Launcher/Languages/sk.xaml

@@ -17,6 +17,7 @@
     <!--Setting General-->
     <system:String x:Key="flowlauncher_settings">Nastavenia Flow Launchera</system:String>
     <system:String x:Key="general">Všeobecné</system:String>
+    <system:String x:Key="portableMode">Prenosný režim</system:String>
     <system:String x:Key="startFlowLauncherOnSystemStartup">Spustiť Flow Launcher po štarte systému</system:String>
     <system:String x:Key="hideFlowLauncherWhenLoseFocus">Schovať Flow Launcher po strate fokusu</system:String>
     <system:String x:Key="dontPromptUpdateMsg">Nezobrazovať upozornenia na novú verziu</system:String>
@@ -39,10 +40,13 @@
     <!--Setting Plugin-->
     <system:String x:Key="plugin">Plugin</system:String>
     <system:String x:Key="browserMorePlugins">Nájsť ďalšie pluginy</system:String>
-    <system:String x:Key="disable">Zakázať</system:String>
+    <system:String x:Key="enable">Povolené</system:String>
+    <system:String x:Key="disable">Zakázané</system:String>
     <system:String x:Key="actionKeywords">Skratka akcie</system:String>
     <system:String x:Key="currentActionKeywords">Aktuálna akcia skratky:</system:String>
     <system:String x:Key="newActionKeyword">Nová akcia skratky:</system:String>
+    <system:String x:Key="currentPriority">Aktuálna priorita:</system:String>
+    <system:String x:Key="newPriority">Nová priorita:</system:String>
     <system:String x:Key="pluginDirectory">Priečinok s pluginmi</system:String>
     <system:String x:Key="author">Autor</system:String>
     <system:String x:Key="plugin_init_time">Príprava:</system:String>
@@ -104,6 +108,10 @@
     </system:String>
     <system:String x:Key="releaseNotes">Poznámky k vydaniu</system:String>
 
+    <!--Priority Setting Dialog-->
+    <system:String x:Key="priority_tips">Vyššie číslo znamená, že výsledok bude vyššie. Skúste nastaviť napr. 5. Ak chcete, aby boli výsledky nižšie ako ktorékoľvek iné doplnky, zadajte záporné číslo</system:String>
+    <system:String x:Key="invalidPriority">Prosím, zadajte platné číslo pre prioritu!</system:String>
+
     <!--Action Keyword Setting Dialog-->
     <system:String x:Key="oldActionKeywords">Stará skratka akcie</system:String>
     <system:String x:Key="newActionKeywords">Nová skratka akcie</system:String>
@@ -116,6 +124,7 @@
     <system:String x:Key="actionkeyword_tips">Použite * ak nechcete určiť skratku pre akciu</system:String>
 
     <!--Custom Query Hotkey Dialog-->
+    <system:String x:Key="customeQueryHotkeyTitle">Vlastná klávesová skratka pre plugin</system:String>
     <system:String x:Key="preview">Náhľad</system:String>
     <system:String x:Key="hotkeyIsNotUnavailable">Klávesová skratka je nedostupná, prosím, zadajte novú</system:String>
     <system:String x:Key="invalidPluginHotkey">Neplatná klávesová skratka pluginu</system:String>
@@ -140,11 +149,23 @@
     <system:String x:Key="reportWindow_report_failed">Odoslanie hlásenia zlyhalo</system:String>
     <system:String x:Key="reportWindow_flowlauncher_got_an_error">Flow Launcher zaznamenal chybu</system:String>
 
+    <!--General Notice-->
+    <system:String x:Key="pleaseWait">Čakajte, prosím…</system:String>
+
     <!--update-->
-    <system:String x:Key="update_flowlauncher_update_new_version_available">Je dostupná nová verzia Flow Launcher {0}</system:String>
+    <system:String x:Key="update_flowlauncher_update_check">Kontrolujú sa akutalizácie</system:String>
+    <system:String x:Key="update_flowlauncher_already_on_latest">Už máte najnovšiu verizu Flow Launchera</system:String>
+    <system:String x:Key="update_flowlauncher_update_found">Bola nájdená aktualizácia</system:String>
+    <system:String x:Key="update_flowlauncher_updating">Aktualizuje sa…</system:String>
+    <system:String x:Key="update_flowlauncher_fail_moving_portable_user_profile_data">Flow Launcher nedokázal presunúť používateľské údaje do aktualizovanej verzie.
+        Prosím, presuňte profilový priečinok „data“ z {0} do {1}</system:String>
+    <system:String x:Key="update_flowlauncher_new_update">Nová aktualizácia</system:String>
+    <system:String x:Key="update_flowlauncher_update_new_version_available">Je dostupná nová verzia Flow Launchera {0}</system:String>
     <system:String x:Key="update_flowlauncher_update_error">Počas inštalácie aktualizácií došlo k chybe</system:String>
     <system:String x:Key="update_flowlauncher_update">Aktualizovať</system:String>
     <system:String x:Key="update_flowlauncher_update_cancel">Zrušiť</system:String>
+    <system:String x:Key="update_flowlauncher_fail">Aktualizácia zlyhala</system:String>
+    <system:String x:Key="update_flowlauncher_check_connection">Skontrolujte pripojenie a skúste aktualizovať nastavenia servera proxy na github-cloud.s3.amazonaws.com.</system:String>
     <system:String x:Key="update_flowlauncher_update_restart_flowlauncher_tip">Tento upgrade reštartuje Flow Launcher</system:String>
     <system:String x:Key="update_flowlauncher_update_upadte_files">Nasledujúce súbory budú aktualizované</system:String>
     <system:String x:Key="update_flowlauncher_update_files">Aktualizovať súbory</system:String>

Flow.Launcher/MainWindow.xaml

@@ -97,7 +97,7 @@
                                      Background="Transparent"/>
                 </Grid>
                 <Line x:Name="ProgressBar" HorizontalAlignment="Right"
-                  Style="{DynamicResource PendingLineStyle}" Visibility="{Binding ProgressBarVisibility, Mode=TwoWay}" 
+                  Style="{DynamicResource PendingLineStyle}" Visibility="{Binding ProgressBarVisibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" 
                   Y1="0" Y2="0" X2="100" Height="2" Width="752" StrokeThickness="1">
                 </Line>
                 <ContentControl>

Flow.Launcher/MainWindow.xaml.cs

@@ -26,6 +26,7 @@ namespace Flow.Launcher
         #region Private Fields
 
         private readonly Storyboard _progressBarStoryboard = new Storyboard();
+        private bool isProgressBarStoryboardPaused;
         private Settings _settings;
         private NotifyIcon _notifyIcon;
         private MainViewModel _viewModel;
@@ -52,7 +53,7 @@ namespace Flow.Launcher
 
         private void OnInitialized(object sender, EventArgs e)
         {
-            
+
         }
 
         private void OnLoaded(object sender, RoutedEventArgs _)
@@ -73,7 +74,7 @@ namespace Flow.Launcher
             {
                 if (e.PropertyName == nameof(MainViewModel.MainWindowVisibility))
                 {
-                    if (Visibility == Visibility.Visible)
+                    if (_viewModel.MainWindowVisibility == Visibility.Visible)
                     {
                         Activate();
                         QueryTextBox.Focus();
@@ -84,7 +85,34 @@ namespace Flow.Launcher
                             QueryTextBox.SelectAll();
                             _viewModel.LastQuerySelected = true;
                         }
+
+                        if (_viewModel.ProgressBarVisibility == Visibility.Visible && isProgressBarStoryboardPaused)
+                        {
+                            _progressBarStoryboard.Resume();
+                            isProgressBarStoryboardPaused = false;
+                        }
                     }
+                    else if (!isProgressBarStoryboardPaused)
+                    {
+                        _progressBarStoryboard.Pause();
+                        isProgressBarStoryboardPaused = true;
+                    }
+                }
+                else if (e.PropertyName == nameof(MainViewModel.ProgressBarVisibility))
+                {
+                    Dispatcher.Invoke(() =>
+                    {
+                        if (_viewModel.ProgressBarVisibility == Visibility.Hidden && !isProgressBarStoryboardPaused)
+                        {
+                            _progressBarStoryboard.Pause();
+                            isProgressBarStoryboardPaused = true;
+                        }
+                        else if (_viewModel.MainWindowVisibility == Visibility.Visible && isProgressBarStoryboardPaused)
+                        {
+                            _progressBarStoryboard.Resume();
+                            isProgressBarStoryboardPaused = false;
+                        }
+                    }, System.Windows.Threading.DispatcherPriority.Render);
                 }
             };
             _settings.PropertyChanged += (o, e) =>
@@ -170,6 +198,7 @@ namespace Flow.Launcher
             _progressBarStoryboard.RepeatBehavior = RepeatBehavior.Forever;
             ProgressBar.BeginStoryboard(_progressBarStoryboard);
             _viewModel.ProgressBarVisibility = Visibility.Hidden;
+            isProgressBarStoryboardPaused = true;
         }
 
         private void OnMouseDown(object sender, MouseButtonEventArgs e)

Flow.Launcher/PriorityChangeWindow.xaml

@@ -0,0 +1,45 @@
+<Window x:Class="Flow.Launcher.PriorityChangeWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:Flow.Launcher"
+        Loaded="PriorityChangeWindow_Loaded"
+        mc:Ignorable="d"
+        WindowStartupLocation="CenterScreen"
+        Title="PriorityChangeWindow" Height="250" Width="300">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition />
+            <RowDefinition Height="60"/>
+            <RowDefinition Height="75"/>
+            <RowDefinition />
+        </Grid.RowDefinitions>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="20" />
+            <ColumnDefinition />
+        </Grid.ColumnDefinitions>
+        <TextBlock FontSize="14" Grid.Row="0" Grid.Column="1" VerticalAlignment="Center"
+                   HorizontalAlignment="Left" Text="{DynamicResource currentPriority}" />
+        <TextBlock x:Name="OldPriority" Grid.Row="0" Grid.Column="1" Margin="170 10 10 10" FontSize="14"
+                   VerticalAlignment="Center" HorizontalAlignment="Left" />
+
+        <TextBlock FontSize="14" Grid.Row="1" Grid.Column="1" VerticalAlignment="Center"
+                   HorizontalAlignment="Left" Text="{DynamicResource newPriority}" />
+        <StackPanel Grid.Row="1" Orientation="Horizontal" Grid.Column="1">
+            <TextBox x:Name="tbAction" Margin="140 10 15 10" Width="105" VerticalAlignment="Center" HorizontalAlignment="Left" />
+        </StackPanel>
+
+        <TextBlock Grid.Row="2" Grid.ColumnSpan="1" Grid.Column="1" Foreground="Gray"
+                   Text="{DynamicResource priority_tips}" TextWrapping="Wrap"
+                   Margin="0,0,20,0"/>
+
+        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Grid.Row="3" Grid.Column="1">
+            <Button x:Name="btnCancel" Click="BtnCancel_OnClick" Margin="10 0 10 0" Width="80" Height="30"
+                    Content="{DynamicResource cancel}" />
+            <Button x:Name="btnDone" Margin="10 0 10 0" Width="80" Height="30" Click="btnDone_OnClick">
+                <TextBlock x:Name="lblAdd" Text="{DynamicResource done}" />
+            </Button>
+        </StackPanel>
+    </Grid>
+</Window>

Flow.Launcher/PriorityChangeWindow.xaml.cs

@@ -0,0 +1,69 @@
+using Flow.Launcher.Core.Plugin;
+using Flow.Launcher.Core.Resource;
+using Flow.Launcher.Infrastructure.UserSettings;
+using Flow.Launcher.Plugin;
+using Flow.Launcher.ViewModel;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+
+namespace Flow.Launcher
+{
+    /// <summary>
+    /// Interaction Logic of PriorityChangeWindow.xaml
+    /// </summary>
+    public partial class PriorityChangeWindow : Window
+    {
+        private readonly PluginPair plugin;
+        private Settings settings;
+        private readonly Internationalization translater = InternationalizationManager.Instance;
+        private readonly PluginViewModel pluginViewModel;
+
+        public PriorityChangeWindow(string pluginId, Settings settings, PluginViewModel pluginViewModel)
+        {
+            InitializeComponent();
+            plugin = PluginManager.GetPluginForId(pluginId);
+            this.settings = settings;
+            this.pluginViewModel = pluginViewModel;
+            if (plugin == null)
+            {
+                MessageBox.Show(translater.GetTranslation("cannotFindSpecifiedPlugin"));
+                Close();
+            }
+        }
+
+        private void BtnCancel_OnClick(object sender, RoutedEventArgs e)
+        {
+            Close();
+        }
+
+        private void btnDone_OnClick(object sender, RoutedEventArgs e)
+        {
+            if (int.TryParse(tbAction.Text.Trim(), out var newPriority))
+            {
+                pluginViewModel.ChangePriority(newPriority);
+                Close();
+            }
+            else
+            {
+                string msg = translater.GetTranslation("invalidPriority");
+                MessageBox.Show(msg);
+            }
+
+        }
+
+        private void PriorityChangeWindow_Loaded(object sender, RoutedEventArgs e)
+        {
+            OldPriority.Text = pluginViewModel.Priority.ToString();
+            tbAction.Focus();
+        }
+    }
+}

Flow.Launcher/Properties/PublishProfiles/NetCore3.1-SelfContained.pubxml

@@ -7,7 +7,7 @@ https://go.microsoft.com/fwlink/?LinkID=208121.
     <PublishProtocol>FileSystem</PublishProtocol>
     <Configuration>Release</Configuration>
     <Platform>Any CPU</Platform>
-    <TargetFramework>net5.0-windows10.0.19041.0</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <PublishDir>..\Output\Release\</PublishDir>
     <RuntimeIdentifier>win-x64</RuntimeIdentifier>
     <SelfContained>true</SelfContained>

Flow.Launcher/PublicAPIInstance.cs

@@ -5,7 +5,6 @@ using System.Net;
 using System.Threading.Tasks;
 using System.Windows;
 using Squirrel;
-using Flow.Launcher.Core;
 using Flow.Launcher.Core.Plugin;
 using Flow.Launcher.Core.Resource;
 using Flow.Launcher.Helper;
@@ -14,6 +13,11 @@ using Flow.Launcher.Infrastructure.Hotkey;
 using Flow.Launcher.Infrastructure.Image;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.ViewModel;
+using Flow.Launcher.Plugin.SharedModels;
+using System.Threading;
+using System.IO;
+using Flow.Launcher.Infrastructure.Http;
+using JetBrains.Annotations;
 
 namespace Flow.Launcher
 {
@@ -78,9 +82,9 @@ namespace Flow.Launcher
             ImageLoader.Save();
         }
 
-        public void ReloadAllPluginData()
+        public Task ReloadAllPluginData()
         {
-            PluginManager.ReloadData();
+            return PluginManager.ReloadData();
         }
 
         public void ShowMsg(string title, string subTitle = "", string iconPath = "")
@@ -92,7 +96,7 @@ namespace Flow.Launcher
         {
             Application.Current.Dispatcher.Invoke(() =>
             {
-                var msg = useMainWindowAsOwner ? new Msg {Owner = Application.Current.MainWindow} : new Msg();
+                var msg = useMainWindowAsOwner ? new Msg { Owner = Application.Current.MainWindow } : new Msg();
                 msg.Show(title, subTitle, iconPath);
             });
         }
@@ -127,6 +131,32 @@ namespace Flow.Launcher
 
         public event FlowLauncherGlobalKeyboardEventHandler GlobalKeyboardEvent;
 
+        public MatchResult FuzzySearch(string query, string stringToCompare) => StringMatcher.FuzzySearch(query, stringToCompare);
+
+        public Task<string> HttpGetStringAsync(string url, CancellationToken token = default)
+        {
+            return Http.GetAsync(url);
+        }
+
+        public Task<Stream> HttpGetStreamAsync(string url, CancellationToken token = default)
+        {
+            return Http.GetStreamAsync(url);
+        }
+
+        public Task HttpDownloadAsync([NotNull] string url, [NotNull] string filePath)
+        {
+            return Http.DownloadAsync(url, filePath);
+        }
+
+        public void AddActionKeyword(string pluginId, string newActionKeyword)
+        {
+            PluginManager.AddActionKeyword(pluginId, newActionKeyword);
+        }
+
+        public void RemoveActionKeyword(string pluginId, string oldActionKeyword)
+        {
+            PluginManager.RemoveActionKeyword(pluginId, oldActionKeyword);
+        }
         #endregion
 
         #region Private Methods
@@ -139,6 +169,7 @@ namespace Flow.Launcher
             }
             return true;
         }
+
         #endregion
     }
 }

Flow.Launcher/ResultListBox.xaml

@@ -9,7 +9,7 @@
          d:DataContext="{d:DesignInstance vm:ResultsViewModel}"
          MaxHeight="{Binding MaxHeight}"
          SelectedIndex="{Binding SelectedIndex, Mode=TwoWay}"
-         SelectedItem="{Binding SelectedItem, Mode=OneWayToSource}"
+         SelectedItem="{Binding SelectedItem, Mode=TwoWay}"
          HorizontalContentAlignment="Stretch" ItemsSource="{Binding Results}"
          Margin="{Binding Margin}"
          Visibility="{Binding Visbility}"

Flow.Launcher/SettingWindow.xaml

@@ -37,7 +37,7 @@
             <ScrollViewer ui:ScrollViewerHelper.AutoHideScrollBars="True" Margin="60,30,0,30">
                 <StackPanel Orientation="Vertical">
                     <ui:ToggleSwitch Margin="10" IsOn="{Binding PortableMode}">
-                        <TextBlock Text="Portable Mode" />
+                        <TextBlock Text="{DynamicResource portableMode}" />
                     </ui:ToggleSwitch>
                     <CheckBox Margin="10" IsChecked="{Binding Settings.StartFlowLauncherOnSystemStartup}"
                           Checked="OnAutoStartupChecked" Unchecked="OnAutoStartupUncheck">
@@ -166,17 +166,21 @@
                                                 </TextBlock>
                                             </ToolTipService.ToolTip>
                                      </TextBlock>
-                                    <ui:ToggleSwitch Grid.Column="1" OffContent="Disabled" OnContent="Enabled" 
+                                    <ui:ToggleSwitch Grid.Column="1" OffContent="{DynamicResource disable}" OnContent="{DynamicResource enable}" 
                                                      MaxWidth="110" HorizontalAlignment="Right"
                                                      IsOn="{Binding PluginState}"/>
                                 </Grid>
                                 <TextBlock Text="{Binding PluginPair.Metadata.Description}"
                                            Grid.Row="1" Opacity="0.5" />
                                 <DockPanel Grid.Row="2" Margin="0 10 0 8" HorizontalAlignment="Right">
-
+                                    <TextBlock Text="Priority" Margin="20,0,0,0"/>
+                                    <TextBlock Text="{Binding Priority}"
+                                               ToolTip="Change Plugin Results Priority"
+                                               Margin="5 0 0 0" Cursor="Hand" Foreground="Blue"
+                                               MouseUp="OnPluginPriorityClick"/>
                                     <TextBlock Text="{DynamicResource actionKeywords}"
                                                Visibility="{Binding ActionKeywordsVisibility}"
-                                               Margin="20 0 0 0"/>
+                                               Margin="5 0 0 0"/>
                                     <TextBlock Text="{Binding ActionKeywordsText}"
                                                Visibility="{Binding ActionKeywordsVisibility}"
                                                ToolTip="Change Action Keywords"

Flow.Launcher/SettingWindow.xaml.cs

@@ -206,7 +206,16 @@ namespace Flow.Launcher
         {
             var id = viewModel.SelectedPlugin.PluginPair.Metadata.ID;
             // used to sync the current status from the plugin manager into the setting to keep consistency after save
-            settings.PluginSettings.Plugins[id].Disabled = viewModel.SelectedPlugin.PluginPair.Metadata.Disabled; 
+            settings.PluginSettings.Plugins[id].Disabled = viewModel.SelectedPlugin.PluginPair.Metadata.Disabled;
+        }
+
+        private void OnPluginPriorityClick(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ChangedButton == MouseButton.Left)
+            {
+                PriorityChangeWindow priorityChangeWindow = new PriorityChangeWindow(viewModel.SelectedPlugin.PluginPair.Metadata.ID, settings, viewModel.SelectedPlugin);
+                priorityChangeWindow.ShowDialog();
+            }
         }
 
         private void OnPluginActionKeywordsClick(object sender, MouseButtonEventArgs e)
@@ -281,5 +290,6 @@ namespace Flow.Launcher
         {
             FilesFolders.OpenPath(Path.Combine(DataLocation.DataDirectory(), Constant.Themes));
         }
+
     }
-}
+}

Flow.Launcher/Storage/TopMostRecord.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using Flow.Launcher.Plugin;
 
 namespace Flow.Launcher.Storage
@@ -8,20 +9,24 @@ namespace Flow.Launcher.Storage
     // todo this class is not thread safe.... but used from multiple threads.
     public class TopMostRecord
     {
-        private Dictionary<string, Record> records = new Dictionary<string, Record>();
+        /// <summary>
+        /// You should not directly access this field
+        /// <para>
+        /// It is public due to System.Text.Json limitation in version 3.1
+        /// </para>
+        /// </summary>
+        /// TODO: Set it to private
+        public Dictionary<string, Record> records { get; set; } = new Dictionary<string, Record>();
 
         internal bool IsTopMost(Result result)
         {
-            if (records.Count == 0)
+            if (records.Count == 0 || !records.ContainsKey(result.OriginQuery.RawQuery))
             {
                 return false;
             }
 
-            // since this dictionary should be very small (or empty) going over it should be pretty fast. 
-            return records.Any(o => o.Value.Title == result.Title
-                                     && o.Value.SubTitle == result.SubTitle
-                                     && o.Value.PluginID == result.PluginID
-                                     && o.Key == result.OriginQuery.RawQuery);
+            // since this dictionary should be very small (or empty) going over it should be pretty fast.
+            return records[result.OriginQuery.RawQuery].Equals(result);
         }
 
         internal void Remove(Result result)
@@ -53,5 +58,12 @@ namespace Flow.Launcher.Storage
         public string Title { get; set; }
         public string SubTitle { get; set; }
         public string PluginID { get; set; }
+
+        public bool Equals(Result r)
+        {
+            return Title == r.Title
+                && SubTitle == r.SubTitle
+                && PluginID == r.PluginID;
+        }
     }
 }

Flow.Launcher/Storage/UserSelectedRecord.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Text.Json.Serialization;
 using Flow.Launcher.Infrastructure.Storage;
 using Flow.Launcher.Plugin;
 
@@ -6,14 +7,27 @@ namespace Flow.Launcher.Storage
 {
     public class UserSelectedRecord
     {
-        private Dictionary<string, int> records = new Dictionary<string, int>();
+        /// <summary>
+        /// You should not directly access this field
+        /// <para>
+        /// It is public due to System.Text.Json limitation in version 3.1
+        /// </para>
+        /// </summary>
+        /// TODO: Set it to private
+        [JsonPropertyName("records")]
+        public Dictionary<string, int> records { get; set; }
+
+        public UserSelectedRecord()
+        {
+            records = new Dictionary<string, int>();
+        }
 
         public void Add(Result result)
         {
             var key = result.ToString();
-            if (records.TryGetValue(key, out int value))
+            if (records.ContainsKey(key))
             {
-                records[key] = value + 1;
+                records[key]++;
             }
             else
             {

Flow.Launcher/Themes/BlurBlack Darker.xaml

@@ -0,0 +1,63 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:system="clr-namespace:System;assembly=mscorlib">
+    <ResourceDictionary.MergedDictionaries>
+        <ResourceDictionary Source="pack://application:,,,/Themes/Base.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+
+    <system:Boolean x:Key="ThemeBlurEnabled">True</system:Boolean>
+
+    <Style x:Key="QueryBoxStyle" BasedOn="{StaticResource BaseQueryBoxStyle}" TargetType="{x:Type TextBox}">
+        <Setter Property="Foreground" Value="#FFFFFFFF" />
+        <Setter Property="Background" Value="Transparent" />
+    </Style>
+
+    <Style x:Key="QuerySuggestionBoxStyle" BasedOn="{StaticResource BaseQuerySuggestionBoxStyle}" TargetType="{x:Type TextBox}">
+        <Setter Property="Foreground" Value="LightGray" />
+    </Style>
+
+    <Style x:Key="WindowBorderStyle" BasedOn="{StaticResource BaseWindowBorderStyle}" TargetType="{x:Type Border}">
+        <Setter Property="Background">
+            <Setter.Value>
+                <SolidColorBrush Color="Black" Opacity="0.6"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="WindowStyle" BasedOn="{StaticResource BaseWindowStyle}" TargetType="{x:Type Window}">
+        <Setter Property="Width" Value="750" /> <!-- This is used to set the blur width only -->
+        <Setter Property="Background">
+            <Setter.Value>
+                <SolidColorBrush Color="Black" Opacity="0.6"/>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="PendingLineStyle" BasedOn="{StaticResource BasePendingLineStyle}" TargetType="{x:Type Line}">
+    </Style>
+
+    <!-- Item Style -->
+    <Style x:Key="ItemTitleStyle"  BasedOn="{StaticResource BaseItemTitleStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Margin" Value="0, -10"/>
+        <Setter Property="Foreground" Value="#FFFFFFFF"/>
+    </Style>
+    <Style x:Key="ItemSubTitleStyle" BasedOn="{StaticResource BaseItemSubTitleStyle}" TargetType="{x:Type TextBlock}" >
+        <Setter Property="Foreground" Value="#FFFFFFFF"/>
+    </Style>
+    <Style x:Key="ItemTitleSelectedStyle" BasedOn="{StaticResource BaseItemTitleSelectedStyle}"  TargetType="{x:Type TextBlock}" >
+        <Setter Property="Margin" Value="0, -10"/>
+        <Setter Property="Foreground" Value="#FFFFFFFF"/>
+    </Style>
+    <Style x:Key="ItemSubTitleSelectedStyle" BasedOn="{StaticResource BaseItemSubTitleSelectedStyle}" TargetType="{x:Type TextBlock}" >
+        <Setter Property="Foreground" Value="#FFFFFFFF"/>
+    </Style>
+    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#356ef3</SolidColorBrush>
+
+    <!-- button style in the middle of the scrollbar -->
+    <Style x:Key="ThumbStyle" BasedOn="{StaticResource BaseThumbStyle}" TargetType="{x:Type Thumb}">
+    </Style>
+
+    <Style x:Key="ScrollBarStyle" BasedOn="{StaticResource BaseScrollBarStyle}" TargetType="{x:Type ScrollBar}">
+        <Setter Property="Background" Value="#a0a0a0"/>
+    </Style>
+</ResourceDictionary>

Flow.Launcher/Themes/BlurWhite.xaml

@@ -17,7 +17,7 @@
     <Style x:Key="WindowBorderStyle" BasedOn="{StaticResource BaseWindowBorderStyle}" TargetType="{x:Type Border}">
         <Setter Property="Background">
             <Setter.Value>
-                <SolidColorBrush Color="White" Opacity="0.1"/>
+                <SolidColorBrush Color="White" Opacity="0.5"/>
             </Setter.Value>
         </Setter>
     </Style>
@@ -26,7 +26,7 @@
         <Setter Property="Width" Value="750" /> <!-- This is used to set the blur width only -->
         <Setter Property="Background">
             <Setter.Value>
-                <SolidColorBrush Color="White" Opacity="0.1"/>
+                <SolidColorBrush Color="White" Opacity="0.5"/>
             </Setter.Value>
         </Setter>
     </Style>

Flow.Launcher/Themes/Gray.xaml

@@ -4,21 +4,19 @@
         <ResourceDictionary Source="pack://application:,,,/Themes/Base.xaml" />
     </ResourceDictionary.MergedDictionaries>
     <Style x:Key="QueryBoxStyle" BasedOn="{StaticResource BaseQueryBoxStyle}" TargetType="{x:Type TextBox}">
-        <Setter Property="Background" Value="#EDEDED" />
+        <Setter Property="Background" Value="LightGray" />
         <Setter Property="Foreground" Value="#222222" />
-        <Setter Property="FontSize" Value="38" />
     </Style>
 
     <Style x:Key="QuerySuggestionBoxStyle" BasedOn="{StaticResource BaseQuerySuggestionBoxStyle}" TargetType="{x:Type TextBox}">
-        <Setter Property="Background" Value="#EDEDED" />
-        <Setter Property="Foreground" Value="#222222" />
-        <Setter Property="FontSize" Value="38" />
+        <Setter Property="Background" Value="LightGray" />
+        <Setter Property="Foreground" Value="#6E6E6E" />
     </Style>
 
     <Style x:Key="WindowBorderStyle" BasedOn="{StaticResource BaseWindowBorderStyle}" TargetType="{x:Type Border}">
-        <Setter Property="BorderBrush" Value="#B0B0B0" />
+        <Setter Property="BorderBrush" Value="LightGray" />
         <Setter Property="BorderThickness" Value="1" />
-        <Setter Property="Background" Value="#EDEDED"></Setter>
+        <Setter Property="Background" Value="LightGray"></Setter>
     </Style>
     <Style x:Key="WindowStyle" TargetType="{x:Type Window}" BasedOn="{StaticResource BaseWindowStyle}" >
     </Style>
@@ -31,15 +29,15 @@
         <Setter Property="Foreground" Value="#A6A6A6" />
     </Style>
     <Style x:Key="ItemSubTitleStyle" BasedOn="{StaticResource BaseItemSubTitleStyle}" TargetType="{x:Type TextBlock}">
-        <Setter Property="Foreground" Value="#A6A6A6" />
+        <Setter Property="Foreground" Value="#6B6B6B" />
     </Style>
     <Style x:Key="ItemTitleSelectedStyle" BasedOn="{StaticResource BaseItemTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
-        <Setter Property="Foreground" Value="#FFFFF8" />
+        <Setter Property="Foreground" Value="White" />
     </Style>
     <Style x:Key="ItemSubTitleSelectedStyle" BasedOn="{StaticResource BaseItemSubTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
-        <Setter Property="Foreground" Value="#ffffff" />
+        <Setter Property="Foreground" Value="#EDEDED" />
     </Style>
-    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#00AAF6</SolidColorBrush>
+    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#787878</SolidColorBrush>
     <Style x:Key="ThumbStyle" BasedOn="{StaticResource BaseThumbStyle}" TargetType="{x:Type Thumb}">
         <Setter Property="Template">
             <Setter.Value>

Flow.Launcher/Themes/Light.xaml

@@ -6,19 +6,19 @@
     </ResourceDictionary.MergedDictionaries>
 
     <Style x:Key="QueryBoxStyle" BasedOn="{StaticResource BaseQueryBoxStyle}" TargetType="{x:Type TextBox}">
-        <Setter Property="Background" Value="#EBEBEB"/>
+        <Setter Property="Background" Value="White "/>
         <Setter Property="Foreground" Value="#000000" />
     </Style>
 
     <Style x:Key="QuerySuggestionBoxStyle" BasedOn="{StaticResource BaseQuerySuggestionBoxStyle}" TargetType="{x:Type TextBox}">
-        <Setter Property="Background" Value="#EBEBEB"/>
+        <Setter Property="Background" Value="White"/>
         <Setter Property="Foreground" Value="#000000" />
     </Style>
 
     <Style x:Key="WindowBorderStyle" BasedOn="{StaticResource BaseWindowBorderStyle}" TargetType="{x:Type Border}">
-        <Setter Property="BorderBrush" Value="#AAAAAA" />
-        <Setter Property="BorderThickness" Value="5" />
-        <Setter Property="Background" Value="#ffffff"></Setter>
+        <Setter Property="BorderBrush" Value="LightGray" />
+        <Setter Property="BorderThickness" Value="1"></Setter>
+        <Setter Property="Background" Value="White"></Setter>
     </Style>
     <Style x:Key="WindowStyle" TargetType="{x:Type Window}" BasedOn="{StaticResource BaseWindowStyle}" >
     </Style>
@@ -38,7 +38,7 @@
     <Style x:Key="ItemSubTitleSelectedStyle" BasedOn="{StaticResource BaseItemSubTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
         <Setter Property="Foreground" Value="#F6F6FF" />
     </Style>
-    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#3875D7</SolidColorBrush>
+    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#909090</SolidColorBrush>
 
     <!-- button style in the middle of the scrollbar -->
     <Style x:Key="ThumbStyle" BasedOn="{StaticResource BaseThumbStyle}" TargetType="{x:Type Thumb}">

Flow.Launcher/Themes/Nord Darker.xaml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <ResourceDictionary.MergedDictionaries>
+        <ResourceDictionary Source="pack://application:,,,/Themes/Base.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+    <Style x:Key="QueryBoxStyle" BasedOn="{StaticResource BaseQueryBoxStyle}" TargetType="{x:Type TextBox}">
+        <Setter Property="Background" Value="#2e3440" />
+        <Setter Property="Foreground" Value="#eceff4" />
+        <Setter Property="FontSize" Value="30" />
+    </Style>
+
+    <Style x:Key="QuerySuggestionBoxStyle" BasedOn="{StaticResource BaseQuerySuggestionBoxStyle}" TargetType="{x:Type TextBox}">
+        <Setter Property="Background" Value="#2e3440" />
+        <Setter Property="Foreground" Value="#eceff4" />
+        <Setter Property="FontSize" Value="30" />
+    </Style>
+
+    <Style x:Key="WindowBorderStyle" BasedOn="{StaticResource BaseWindowBorderStyle}" TargetType="{x:Type Border}">
+        <Setter Property="BorderBrush" Value="#4c566a" />
+        <Setter Property="BorderThickness" Value="1" />
+        <Setter Property="Background" Value="#2e3440"></Setter>
+    </Style>
+    <Style x:Key="WindowStyle" TargetType="{x:Type Window}" BasedOn="{StaticResource BaseWindowStyle}" >
+    </Style>
+    <Style x:Key="PendingLineStyle" BasedOn="{StaticResource BasePendingLineStyle}" TargetType="{x:Type Line}" />
+    <Style x:Key="ItemTitleStyle" BasedOn="{StaticResource BaseItemTitleStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#e5e9f0" />
+        <Setter Property="FontWeight" Value="Bold" />
+    </Style>
+    <Style x:Key="ItemNumberStyle" BasedOn="{StaticResource BaseItemNumberStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#A6A6A6" />
+    </Style>
+    <Style x:Key="ItemSubTitleStyle" BasedOn="{StaticResource BaseItemSubTitleStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#d8dee9" />
+    </Style>
+    <Style x:Key="ItemTitleSelectedStyle" BasedOn="{StaticResource BaseItemTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#2e3440" />
+    </Style>
+    <Style x:Key="ItemSubTitleSelectedStyle" BasedOn="{StaticResource BaseItemSubTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#4c566a" />
+    </Style>
+    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#5e81ac</SolidColorBrush>
+    <Style x:Key="ThumbStyle" BasedOn="{StaticResource BaseThumbStyle}" TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border CornerRadius="2" DockPanel.Dock="Right" Background="#4c566a" BorderBrush="Transparent" BorderThickness="0" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="ScrollBarStyle" BasedOn="{StaticResource BaseScrollBarStyle}" TargetType="{x:Type ScrollBar}" >
+        <Setter Property="Width" Value="3"/>
+    </Style>
+</ResourceDictionary>

Flow.Launcher/Themes/Nord.xaml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <ResourceDictionary.MergedDictionaries>
+        <ResourceDictionary Source="pack://application:,,,/Themes/Base.xaml" />
+    </ResourceDictionary.MergedDictionaries>
+    <Style x:Key="QueryBoxStyle" BasedOn="{StaticResource BaseQueryBoxStyle}" TargetType="{x:Type TextBox}">
+        <Setter Property="Background" Value="#4c566a" />
+        <Setter Property="Foreground" Value="#eceff4" />
+        <Setter Property="FontSize" Value="30" />
+    </Style>
+
+    <Style x:Key="QuerySuggestionBoxStyle" BasedOn="{StaticResource BaseQuerySuggestionBoxStyle}" TargetType="{x:Type TextBox}">
+        <Setter Property="Background" Value="#4c566a" />
+        <Setter Property="Foreground" Value="#eceff4" />
+        <Setter Property="FontSize" Value="30" />
+    </Style>
+
+    <Style x:Key="WindowBorderStyle" BasedOn="{StaticResource BaseWindowBorderStyle}" TargetType="{x:Type Border}">
+        <Setter Property="BorderBrush" Value="#2e3440" />
+        <Setter Property="BorderThickness" Value="1" />
+        <Setter Property="Background" Value="#4c566a"></Setter>
+    </Style>
+    <Style x:Key="WindowStyle" TargetType="{x:Type Window}" BasedOn="{StaticResource BaseWindowStyle}" >
+    </Style>
+    <Style x:Key="PendingLineStyle" BasedOn="{StaticResource BasePendingLineStyle}" TargetType="{x:Type Line}" />
+    <Style x:Key="ItemTitleStyle" BasedOn="{StaticResource BaseItemTitleStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#e5e9f0" />
+        <Setter Property="FontWeight" Value="Bold" />
+    </Style>
+    <Style x:Key="ItemNumberStyle" BasedOn="{StaticResource BaseItemNumberStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#A6A6A6" />
+    </Style>
+    <Style x:Key="ItemSubTitleStyle" BasedOn="{StaticResource BaseItemSubTitleStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#d8dee9" />
+    </Style>
+    <Style x:Key="ItemTitleSelectedStyle" BasedOn="{StaticResource BaseItemTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#2e3440" />
+    </Style>
+    <Style x:Key="ItemSubTitleSelectedStyle" BasedOn="{StaticResource BaseItemSubTitleSelectedStyle}" TargetType="{x:Type TextBlock}">
+        <Setter Property="Foreground" Value="#4c566a" />
+    </Style>
+    <SolidColorBrush x:Key="ItemSelectedBackgroundColor">#5e81ac</SolidColorBrush>
+    <Style x:Key="ThumbStyle" BasedOn="{StaticResource BaseThumbStyle}" TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border CornerRadius="2" DockPanel.Dock="Right" Background="#2e3440" BorderBrush="Transparent" BorderThickness="0" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <Style x:Key="ScrollBarStyle" BasedOn="{StaticResource BaseScrollBarStyle}" TargetType="{x:Type ScrollBar}" >
+        <Setter Property="Width" Value="3"/>
+    </Style>
+</ResourceDictionary>

Flow.Launcher/ViewModel/MainViewModel.cs

@@ -1,10 +1,9 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
-using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Threading.Tasks.Dataflow;
 using System.Windows;
 using System.Windows.Input;
 using NHotkey;
@@ -19,8 +18,6 @@ using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedCommands;
 using Flow.Launcher.Storage;
-using System.Windows.Media;
-using Flow.Launcher.Infrastructure.Image;
 using Flow.Launcher.Infrastructure.Logger;
 
 namespace Flow.Launcher.ViewModel
@@ -49,6 +46,9 @@ namespace Flow.Launcher.ViewModel
 
         private readonly Internationalization _translator = InternationalizationManager.Instance;
 
+        private BufferBlock<ResultsForUpdate> _resultsUpdateQueue;
+        private Task _resultsViewUpdateTask;
+
         #endregion
 
         #region Constructor
@@ -75,6 +75,7 @@ namespace Flow.Launcher.ViewModel
             _selectedResults = Results;
 
             InitializeKeyCommands();
+            RegisterViewUpdate();
             RegisterResultsUpdatedEvent();
 
             SetHotkey(_settings.Hotkey, OnHotkey);
@@ -82,6 +83,44 @@ namespace Flow.Launcher.ViewModel
             SetOpenResultModifiers();
         }
 
+        private void RegisterViewUpdate()
+        {
+            _resultsUpdateQueue = new BufferBlock<ResultsForUpdate>();
+            _resultsViewUpdateTask =
+                Task.Run(updateAction).ContinueWith(continueAction, TaskContinuationOptions.OnlyOnFaulted);
+
+
+            async Task updateAction()
+            {
+                var queue = new Dictionary<string, ResultsForUpdate>();
+                while (await _resultsUpdateQueue.OutputAvailableAsync())
+                {
+                    queue.Clear();
+                    await Task.Delay(20);
+                    while (_resultsUpdateQueue.TryReceive(out var item))
+                    {
+                        if (!item.Token.IsCancellationRequested)
+                            queue[item.ID] = item;
+                    }
+
+                    UpdateResultView(queue.Values);
+                }
+            }
+
+            ;
+
+            void continueAction(Task t)
+            {
+#if DEBUG
+                throw t.Exception;
+#else
+                Log.Error($"Error happen in task dealing with viewupdate for results. {t.Exception}");
+                _resultsViewUpdateTask =
+ Task.Run(updateAction).ContinueWith(continueAction, TaskContinuationOptions.OnlyOnFaulted);
+#endif
+            }
+        }
+
         private void RegisterResultsUpdatedEvent()
         {
             foreach (var pair in PluginManager.GetPluginsForInterface<IResultUpdated>())
@@ -89,11 +128,11 @@ namespace Flow.Launcher.ViewModel
                 var plugin = (IResultUpdated)pair.Plugin;
                 plugin.ResultsUpdated += (s, e) =>
                 {
-                    Task.Run(() =>
+                    if (e.Query.RawQuery == QueryText) // TODO: allow cancellation
                     {
                         PluginManager.UpdatePluginMetadata(e.Results, pair.Metadata, e.Query);
-                        UpdateResultView(e.Results, pair.Metadata, e.Query);
-                    }, _updateToken);
+                        _resultsUpdateQueue.Post(new ResultsForUpdate(e.Results, pair.Metadata, e.Query, _updateToken));
+                    }
                 };
             }
         }
@@ -113,25 +152,13 @@ namespace Flow.Launcher.ViewModel
                 }
             });
 
-            SelectNextItemCommand = new RelayCommand(_ =>
-            {
-                SelectedResults.SelectNextResult();
-            });
+            SelectNextItemCommand = new RelayCommand(_ => { SelectedResults.SelectNextResult(); });
 
-            SelectPrevItemCommand = new RelayCommand(_ =>
-            {
-                SelectedResults.SelectPrevResult();
-            });
+            SelectPrevItemCommand = new RelayCommand(_ => { SelectedResults.SelectPrevResult(); });
 
-            SelectNextPageCommand = new RelayCommand(_ =>
-            {
-                SelectedResults.SelectNextPage();
-            });
+            SelectNextPageCommand = new RelayCommand(_ => { SelectedResults.SelectNextPage(); });
 
-            SelectPrevPageCommand = new RelayCommand(_ =>
-            {
-                SelectedResults.SelectPrevPage();
-            });
+            SelectPrevPageCommand = new RelayCommand(_ => { SelectedResults.SelectPrevPage(); });
 
             SelectFirstResultCommand = new RelayCommand(_ => SelectedResults.SelectFirstResult());
 
@@ -209,9 +236,10 @@ namespace Flow.Launcher.ViewModel
         public ResultsViewModel History { get; private set; }
 
         private string _queryText;
+
         public string QueryText
         {
-            get { return _queryText; }
+            get => _queryText;
             set
             {
                 _queryText = value;
@@ -229,10 +257,12 @@ namespace Flow.Launcher.ViewModel
             QueryTextCursorMovedToEnd = true;
             QueryText = queryText;
         }
+
         public bool LastQuerySelected { get; set; }
         public bool QueryTextCursorMovedToEnd { get; set; }
 
         private ResultsViewModel _selectedResults;
+
         private ResultsViewModel SelectedResults
         {
             get { return _selectedResults; }
@@ -264,6 +294,7 @@ namespace Flow.Launcher.ViewModel
                         QueryText = string.Empty;
                     }
                 }
+
                 _selectedResults.Visbility = Visibility.Visible;
             }
         }
@@ -323,9 +354,20 @@ namespace Flow.Launcher.ViewModel
                 {
                     var filtered = results.Where
                     (
-                        r => StringMatcher.FuzzySearch(query, r.Title).IsSearchPrecisionScoreMet()
-                            || StringMatcher.FuzzySearch(query, r.SubTitle).IsSearchPrecisionScoreMet()
-                    ).ToList();
+                        r =>
+                        {
+                            var match = StringMatcher.FuzzySearch(query, r.Title);
+                            if (!match.IsSearchPrecisionScoreMet())
+                            {
+                                match = StringMatcher.FuzzySearch(query, r.SubTitle);
+                            }
+
+                            if (!match.IsSearchPrecisionScoreMet()) return false;
+
+                            r.Score = match.Score;
+                            return true;
+
+                        }).ToList();
                     ContextMenu.AddResults(filtered, id);
                 }
                 else
@@ -379,100 +421,128 @@ namespace Flow.Launcher.ViewModel
 
         private void QueryResults()
         {
-            if (!string.IsNullOrEmpty(QueryText))
+            _updateSource?.Cancel();
+
+            if (string.IsNullOrWhiteSpace(QueryText))
             {
-                _updateSource?.Cancel();
-                var currentUpdateSource = new CancellationTokenSource();
-                _updateSource = currentUpdateSource;
-                var currentCancellationToken = _updateSource.Token;
-                _updateToken = currentCancellationToken;
+                Results.Clear();
+                Results.Visbility = Visibility.Collapsed;
+                return;
+            }
 
-                ProgressBarVisibility = Visibility.Hidden;
-                _isQueryRunning = true;
-                var query = QueryBuilder.Build(QueryText.Trim(), PluginManager.NonGlobalPlugins);
-                if (query != null)
+            _updateSource?.Dispose();
+
+            var currentUpdateSource = new CancellationTokenSource();
+            _updateSource = currentUpdateSource;
+            var currentCancellationToken = _updateSource.Token;
+            _updateToken = currentCancellationToken;
+
+            ProgressBarVisibility = Visibility.Hidden;
+            _isQueryRunning = true;
+
+            var query = QueryBuilder.Build(QueryText.Trim(), PluginManager.NonGlobalPlugins);
+
+            // handle the exclusiveness of plugin using action keyword
+            RemoveOldQueryResults(query);
+
+            _lastQuery = query;
+
+            var plugins = PluginManager.ValidPluginsForQuery(query);
+
+            Task.Run(async () =>
                 {
-                    // handle the exclusiveness of plugin using action keyword
-                    RemoveOldQueryResults(query);
+                    if (query.ActionKeyword == Plugin.Query.GlobalPluginWildcardSign)
+                    {
+                        // Wait 45 millisecond for query change in global query
+                        // if query changes, return so that it won't be calculated
+                        await Task.Delay(45, currentCancellationToken);
+                        if (currentCancellationToken.IsCancellationRequested)
+                            return;
+                    }
 
-                    _lastQuery = query;
-                    Task.Delay(200, currentCancellationToken).ContinueWith(_ =>
-                    { // start the progress bar if query takes more than 200 ms and this is the current running query and it didn't finish yet
-                        if (currentUpdateSource == _updateSource && _isQueryRunning)
+                    _ = Task.Delay(200, currentCancellationToken).ContinueWith(_ =>
+                    {
+                        // start the progress bar if query takes more than 200 ms and this is the current running query and it didn't finish yet
+                        if (!currentCancellationToken.IsCancellationRequested && _isQueryRunning)
                         {
                             ProgressBarVisibility = Visibility.Visible;
                         }
                     }, currentCancellationToken);
 
-                    var plugins = PluginManager.ValidPluginsForQuery(query);
-                    Task.Run(() =>
+                    Task[] tasks = new Task[plugins.Count];
+                    try
                     {
-                        // so looping will stop once it was cancelled
-                        var parallelOptions = new ParallelOptions { CancellationToken = currentCancellationToken };
-                        try
+                        for (var i = 0; i < plugins.Count; i++)
                         {
-                            Parallel.ForEach(plugins, parallelOptions, plugin =>
+                            if (!plugins[i].Metadata.Disabled)
                             {
-                                if (!plugin.Metadata.Disabled)
-                                {
-                                    try
-                                    {
-                                        var results = PluginManager.QueryForPlugin(plugin, query);
-                                        UpdateResultView(results, plugin.Metadata, query);
-                                    }
-                                    catch(Exception e)
-                                    {
-                                        Log.Exception("MainViewModel", $"Exception when querying the plugin {plugin.Metadata.Name}", e, "QueryResults");
-                                    }
-                                }
-                            });
+                                tasks[i] = QueryTask(plugins[i]);
+                            }
+                            else
+                            {
+                                tasks[i] = Task.CompletedTask; // Avoid Null
+                            }
                         }
-                        catch (OperationCanceledException)
-                        {
-                            // nothing to do here
-                        }
-                        
 
-                        // this should happen once after all queries are done so progress bar should continue
-                        // until the end of all querying
-                        _isQueryRunning = false;
-                        if (currentUpdateSource == _updateSource)
-                        { // update to hidden if this is still the current query
-                            ProgressBarVisibility = Visibility.Hidden;
-                        }
-                    }, currentCancellationToken).ContinueWith(t =>
+                        // Check the code, WhenAll will translate all type of IEnumerable or Collection to Array, so make an array at first
+                        await Task.WhenAll(tasks);
+                    }
+                    catch (OperationCanceledException)
                     {
-                        Log.Exception("MainViewModel", "Error when querying plugins", t.Exception?.InnerException, "QueryResults");
-                    }, TaskContinuationOptions.OnlyOnFaulted);
-                }
-            }
-            else
-            {
-                Results.Clear();
-                Results.Visbility = Visibility.Collapsed;
-            }
+                        // nothing to do here
+                    }
+
+                    if (currentCancellationToken.IsCancellationRequested)
+                        return;
+
+                    // this should happen once after all queries are done so progress bar should continue
+                    // until the end of all querying
+                    _isQueryRunning = false;
+                    if (!currentCancellationToken.IsCancellationRequested)
+                    {
+                        // update to hidden if this is still the current query
+                        ProgressBarVisibility = Visibility.Hidden;
+                    }
+
+                    // Local function
+                    async Task QueryTask(PluginPair plugin)
+                    {
+                        // Since it is wrapped within a Task.Run, the synchronous context is null
+                        // Task.Yield will force it to run in ThreadPool
+                        await Task.Yield();
+
+                        var results = await PluginManager.QueryForPlugin(plugin, query, currentCancellationToken);
+                        if (!currentCancellationToken.IsCancellationRequested && results != null)
+                            _resultsUpdateQueue.Post(new ResultsForUpdate(results, plugin.Metadata, query,
+                                currentCancellationToken));
+                    }
+                }, currentCancellationToken)
+                .ContinueWith(t => Log.Exception("|MainViewModel|Plugins Query Exceptions", t.Exception),
+                    TaskContinuationOptions.OnlyOnFaulted);
         }
 
+
         private void RemoveOldQueryResults(Query query)
         {
             string lastKeyword = _lastQuery.ActionKeyword;
+
             string keyword = query.ActionKeyword;
             if (string.IsNullOrEmpty(lastKeyword))
             {
                 if (!string.IsNullOrEmpty(keyword))
                 {
-                    Results.RemoveResultsExcept(PluginManager.NonGlobalPlugins[keyword].Metadata);
+                    Results.KeepResultsFor(PluginManager.NonGlobalPlugins[keyword].Metadata);
                 }
             }
             else
             {
                 if (string.IsNullOrEmpty(keyword))
                 {
-                    Results.RemoveResultsFor(PluginManager.NonGlobalPlugins[lastKeyword].Metadata);
+                    Results.KeepResultsExcept(PluginManager.NonGlobalPlugins[lastKeyword].Metadata);
                 }
                 else if (lastKeyword != keyword)
                 {
-                    Results.RemoveResultsExcept(PluginManager.NonGlobalPlugins[keyword].Metadata);
+                    Results.KeepResultsFor(PluginManager.NonGlobalPlugins[keyword].Metadata);
                 }
             }
         }
@@ -510,6 +580,7 @@ namespace Flow.Launcher.ViewModel
                     }
                 };
             }
+
             return menu;
         }
 
@@ -549,12 +620,12 @@ namespace Flow.Launcher.ViewModel
             return selected;
         }
 
-
         private bool HistorySelected()
         {
             var selected = SelectedResults == History;
             return selected;
         }
+
         #region Hotkey
 
         private void SetHotkey(string hotkeyStr, EventHandler<HotkeyEventArgs> action)
@@ -573,7 +644,8 @@ namespace Flow.Launcher.ViewModel
             catch (Exception)
             {
                 string errorMsg =
-                    string.Format(InternationalizationManager.Instance.GetTranslation("registerHotkeyFailed"), hotkeyStr);
+                    string.Format(InternationalizationManager.Instance.GetTranslation("registerHotkeyFailed"),
+                        hotkeyStr);
                 MessageBox.Show(errorMsg);
             }
         }
@@ -623,7 +695,6 @@ namespace Flow.Launcher.ViewModel
         {
             if (!ShouldIgnoreHotkeys())
             {
-
                 if (_settings.LastQueryMode == LastQueryMode.Empty)
                 {
                     ChangeQueryText(string.Empty);
@@ -677,29 +748,47 @@ namespace Flow.Launcher.ViewModel
         /// <summary>
         /// To avoid deadlock, this method should not called from main thread
         /// </summary>
-        public void UpdateResultView(List<Result> list, PluginMetadata metadata, Query originQuery)
+        public void UpdateResultView(IEnumerable<ResultsForUpdate> resultsForUpdates)
         {
-            foreach (var result in list)
+            if (!resultsForUpdates.Any())
+                return;
+            CancellationToken token;
+
+            try
             {
-                if (_topMostRecord.IsTopMost(result))
+                // Don't know why sometimes even resultsForUpdates is empty, the method won't return;
+                token = resultsForUpdates.Select(r => r.Token).Distinct().SingleOrDefault();
+            }
+#if DEBUG
+            catch
+            {
+                throw new ArgumentException("Unacceptable token");
+            }
+#else
+            catch
+            {
+                token = default;
+            }
+#endif
+
+
+            foreach (var metaResults in resultsForUpdates)
+            {
+                foreach (var result in metaResults.Results)
                 {
-                    result.Score = int.MaxValue;
-                }
-                else
-                {
-                    result.Score += _userSelectedRecord.GetSelectedCount(result) * 5;
+                    if (_topMostRecord.IsTopMost(result))
+                    {
+                        result.Score = int.MaxValue;
+                    }
+                    else
+                    {
+                        var priorityScore = metaResults.Metadata.Priority * 150;
+                        result.Score += _userSelectedRecord.GetSelectedCount(result) * 5 + priorityScore;
+                    }
                 }
             }
 
-            if (originQuery.RawQuery == _lastQuery.RawQuery)
-            {
-                Results.AddResults(list, metadata.ID);
-            }
-
-            if (Results.Visbility != Visibility.Visible && list.Count > 0)
-            {
-                Results.Visbility = Visibility.Visible;
-            }
+            Results.AddResults(resultsForUpdates, token);
         }
 
         #endregion

Flow.Launcher/ViewModel/PluginViewModel.cs

@@ -26,6 +26,7 @@ namespace Flow.Launcher.ViewModel
         public string InitilizaTime => PluginPair.Metadata.InitTime.ToString() + "ms";
         public string QueryTime => PluginPair.Metadata.AvgQueryTime + "ms";
         public string ActionKeywordsText => string.Join(Query.ActionKeywordSeperater, PluginPair.Metadata.ActionKeywords);
+        public int Priority => PluginPair.Metadata.Priority;
 
         public void ChangeActionKeyword(string newActionKeyword, string oldActionKeyword)
         {
@@ -34,6 +35,12 @@ namespace Flow.Launcher.ViewModel
             OnPropertyChanged(nameof(ActionKeywordsText));
         }
 
+        public void ChangePriority(int newPriority)
+        {
+            PluginPair.Metadata.Priority = newPriority;
+            OnPropertyChanged(nameof(Priority));
+        }
+
         public bool IsActionKeywordRegistered(string newActionKeyword) => PluginManager.ActionKeywordRegistered(newActionKeyword);
     }
 }

Flow.Launcher/ViewModel/ResultViewModel.cs

@@ -1,9 +1,7 @@
 using System;
-using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Media;
-using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Infrastructure.Image;
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
@@ -106,14 +104,10 @@ namespace Flow.Launcher.ViewModel
             }
 
             if (ImageLoader.CacheContainImage(imagePath))
-            {
                 // will get here either when icoPath has value\icon delegate is null\when had exception in delegate
                 return ImageLoader.Load(imagePath);
-            }
-            else
-            {
-                return await Task.Run(() => ImageLoader.Load(imagePath));
-            }
+            
+            return await Task.Run(() => ImageLoader.Load(imagePath));
         }
 
         public Result Result { get; }

Flow.Launcher/ViewModel/ResultsForUpdate.cs

@@ -0,0 +1,35 @@
+using Flow.Launcher.Plugin;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace Flow.Launcher.ViewModel
+{
+    public class ResultsForUpdate
+    {
+        public List<Result> Results { get; }
+
+        public PluginMetadata Metadata { get; }
+        public string ID { get; }
+
+        public Query Query { get; }
+        public CancellationToken Token { get; }
+
+        public ResultsForUpdate(List<Result> results, string resultID, CancellationToken token)
+        {
+            Results = results;
+            ID = resultID;
+            Token = token;
+        }
+
+        public ResultsForUpdate(List<Result> results, PluginMetadata metadata, Query query, CancellationToken token)
+        {
+            Results = results;
+            Metadata = metadata;
+            Query = query;
+            Token = token;
+            ID = metadata.ID;
+        }
+    }
+}

Flow.Launcher/ViewModel/ResultsViewModel.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
@@ -17,7 +20,6 @@ namespace Flow.Launcher.ViewModel
 
         public ResultCollection Results { get; }
 
-        private readonly object _addResultsLock = new object();
         private readonly object _collectionLock = new object();
         private readonly Settings _settings;
         private int MaxResults => _settings?.MaxResultsToShow ?? 6;
@@ -116,17 +118,20 @@ namespace Flow.Launcher.ViewModel
 
         public void Clear()
         {
-            Results.Clear();
+            lock (_collectionLock)
+                Results.RemoveAll();
         }
 
-        public void RemoveResultsExcept(PluginMetadata metadata)
+        public void KeepResultsFor(PluginMetadata metadata)
         {
-            Results.RemoveAll(r => r.Result.PluginID != metadata.ID);
+            lock (_collectionLock)
+                Results.Update(Results.Where(r => r.Result.PluginID == metadata.ID).ToList());
         }
 
-        public void RemoveResultsFor(PluginMetadata metadata)
+        public void KeepResultsExcept(PluginMetadata metadata)
         {
-            Results.RemoveAll(r => r.Result.PluginID == metadata.ID);
+            lock (_collectionLock)
+                Results.Update(Results.Where(r => r.Result.PluginID != metadata.ID).ToList());
         }
 
         /// <summary>
@@ -134,70 +139,73 @@ namespace Flow.Launcher.ViewModel
         /// </summary>
         public void AddResults(List<Result> newRawResults, string resultId)
         {
-            lock (_addResultsLock)
+            var newResults = NewResults(newRawResults, resultId);
+
+            UpdateResults(newResults);
+        }
+        /// <summary>
+        /// To avoid deadlock, this method should not called from main thread
+        /// </summary>
+        public void AddResults(IEnumerable<ResultsForUpdate> resultsForUpdates, CancellationToken token)
+        {
+            var newResults = NewResults(resultsForUpdates);
+
+            if (token.IsCancellationRequested)
+                return;
+
+            UpdateResults(newResults, token);
+        }
+
+        private void UpdateResults(List<ResultViewModel> newResults, CancellationToken token = default)
+        {
+            lock (_collectionLock)
             {
-                var newResults = NewResults(newRawResults, resultId);
-
                 // update UI in one run, so it can avoid UI flickering
-                Results.Update(newResults);
+                Results.Update(newResults, token);
+                if (Results.Any())
+                    SelectedItem = Results[0];
+            }
 
-                if (Results.Count > 0)
-                {
+            switch (Visbility)
+            {
+                case Visibility.Collapsed when Results.Count > 0:
                     Margin = new Thickness { Top = 8 };
                     SelectedIndex = 0;
-                }
-                else
-                {
+                    Visbility = Visibility.Visible;
+                    break;
+                case Visibility.Visible when Results.Count == 0:
                     Margin = new Thickness { Top = 0 };
-                }
+                    Visbility = Visibility.Collapsed;
+                    break;
             }
         }
 
         private List<ResultViewModel> NewResults(List<Result> newRawResults, string resultId)
         {
-            var results = Results.ToList();
-            var newResults = newRawResults.Select(r => new ResultViewModel(r, _settings)).ToList();
-            var oldResults = results.Where(r => r.Result.PluginID == resultId).ToList();
+            if (newRawResults.Count == 0)
+                return Results.ToList();
 
-            // Find the same results in A (old results) and B (new newResults)          
-            var sameResults = oldResults
-                                .Where(t1 => newResults.Any(x => x.Result.Equals(t1.Result)))
-                                .ToList();
+            var results = Results as IEnumerable<ResultViewModel>;
 
-            // remove result of relative complement of B in A
-            foreach (var result in oldResults.Except(sameResults))
-            {
-                results.Remove(result);
-            }
+            var newResults = newRawResults.Select(r => new ResultViewModel(r, _settings));
 
-            // update result with B's score and index position
-            foreach (var sameResult in sameResults)
-            {
-                int oldIndex = results.IndexOf(sameResult);
-                int oldScore = results[oldIndex].Result.Score;
-                var newResult = newResults[newResults.IndexOf(sameResult)];
-                int newScore = newResult.Result.Score;
-                if (newScore != oldScore)
-                {
-                    var oldResult = results[oldIndex];
+            return results.Where(r => r.Result.PluginID != resultId)
+                .Concat(newResults)
+                .OrderByDescending(r => r.Result.Score)
+                .ToList();
+        }
 
-                    oldResult.Result.Score = newScore;
-                    oldResult.Result.OriginQuery = newResult.Result.OriginQuery;
+        private List<ResultViewModel> NewResults(IEnumerable<ResultsForUpdate> resultsForUpdates)
+        {
+            if (!resultsForUpdates.Any())
+                return Results.ToList();
 
-                    results.RemoveAt(oldIndex);
-                    int newIndex = InsertIndexOf(newScore, results);
-                    results.Insert(newIndex, oldResult);
-                }
-            }
+            var results = Results as IEnumerable<ResultViewModel>;
 
-            // insert result in relative complement of A in B
-            foreach (var result in newResults.Except(sameResults))
-            {
-                int newIndex = InsertIndexOf(result.Result.Score, results);
-                results.Insert(newIndex, result);
-            }
-
-            return results;
+            return results.Where(r => r != null && !resultsForUpdates.Any(u => u.Metadata.ID == r.Result.PluginID))
+                          .Concat(resultsForUpdates.SelectMany(u => u.Results, (u, r) => new ResultViewModel(r, _settings)))
+                          .OrderByDescending(rv => rv.Result.Score)
+                          .ToList();
         }
         #endregion
 
@@ -232,60 +240,78 @@ namespace Flow.Launcher.ViewModel
         }
         #endregion
 
-        public class ResultCollection : ObservableCollection<ResultViewModel>
+        public class ResultCollection : List<ResultViewModel>, INotifyCollectionChanged
         {
+            private long editTime = 0;
 
-            public void RemoveAll(Predicate<ResultViewModel> predicate)
+            private CancellationToken _token;
+
+            public event NotifyCollectionChangedEventHandler CollectionChanged;
+
+
+            protected void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
             {
-                CheckReentrancy();
+                CollectionChanged?.Invoke(this, e);
+            }
 
-                for (int i = Count - 1; i >= 0; i--)
+            public void BulkAddAll(List<ResultViewModel> resultViews)
+            {
+                AddRange(resultViews);
+
+                // can return because the list will be cleared next time updated, which include a reset event
+                if (_token.IsCancellationRequested)
+                    return;
+
+                // manually update event
+                // wpf use directx / double buffered already, so just reset all won't cause ui flickering
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            }
+            private void AddAll(List<ResultViewModel> Items)
+            {
+                for (int i = 0; i < Items.Count; i++)
                 {
-                    if (predicate(this[i]))
-                    {
-                        RemoveAt(i);
-                    }
+                    var item = Items[i];
+                    if (_token.IsCancellationRequested)
+                        return;
+                    Add(item);
+                    OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, i));
                 }
             }
+            public void RemoveAll(int Capacity = 512)
+            {
+                Clear();
+                if (this.Capacity > 8000 && Capacity < this.Capacity)
+                    this.Capacity = Capacity;
+
+                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            }
 
             /// <summary>
             /// Update the results collection with new results, try to keep identical results
             /// </summary>
             /// <param name="newItems"></param>
-            public void Update(List<ResultViewModel> newItems)
+            public void Update(List<ResultViewModel> newItems, CancellationToken token = default)
             {
-                int newCount = newItems.Count;
-                int oldCount = Items.Count;
-                int location = newCount > oldCount ? oldCount : newCount;
+                _token = token;
+                if (Count == 0 && newItems.Count == 0 || _token.IsCancellationRequested)
+                    return;
 
-                for (int i = 0; i < location; i++)
+                if (editTime < 10 || newItems.Count < 30)
                 {
-                    ResultViewModel oldResult = this[i];
-                    ResultViewModel newResult = newItems[i];
-                    if (!oldResult.Equals(newResult))
-                    { // result is not the same update it in the current index
-                        this[i] = newResult;
-                    }
-                    else if (oldResult.Result.Score != newResult.Result.Score)
-                    {
-                        this[i].Result.Score = newResult.Result.Score;
-                    }
-                }
-
-
-                if (newCount >= oldCount)
-                {
-                    for (int i = oldCount; i < newCount; i++)
-                    {
-                        Add(newItems[i]);
-                    }
+                    if (Count != 0) RemoveAll(newItems.Count);
+                    AddAll(newItems);
+                    editTime++;
+                    return;
                 }
                 else
                 {
-                    for (int i = oldCount - 1; i >= newCount; i--)
+                    Clear();
+                    BulkAddAll(newItems);
+                    if (Capacity > 8000 && newItems.Count < 3000)
                     {
-                        RemoveAt(i);
+                        Capacity = newItems.Count;
                     }
+                    editTime++;
                 }
             }
         }

Flow.Launcher/ViewModel/SettingWindowViewModel.cs

@@ -17,6 +17,7 @@ using Flow.Launcher.Infrastructure.Image;
 using Flow.Launcher.Infrastructure.Storage;
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
+using Flow.Launcher.Plugin.SharedModels;
 
 namespace Flow.Launcher.ViewModel
 {
@@ -88,6 +89,7 @@ namespace Flow.Launcher.ViewModel
                 var id = vm.PluginPair.Metadata.ID;
 
                 Settings.PluginSettings.Plugins[id].Disabled = vm.PluginPair.Metadata.Disabled;
+                Settings.PluginSettings.Plugins[id].Priority = vm.Priority;
             }
 
             PluginManager.Save();
@@ -152,7 +154,7 @@ namespace Flow.Launcher.ViewModel
             {
                 var precisionStrings = new List<string>();
 
-                var enumList = Enum.GetValues(typeof(StringMatcher.SearchPrecisionScore)).Cast<StringMatcher.SearchPrecisionScore>().ToList();
+                var enumList = Enum.GetValues(typeof(SearchPrecisionScore)).Cast<SearchPrecisionScore>().ToList();
 
                 enumList.ForEach(x => precisionStrings.Add(x.ToString()));
 

Plugins/Flow.Launcher.Plugin.BrowserBookmark/Commands/Bookmarks.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Flow.Launcher.Infrastructure;
+using Flow.Launcher.Plugin.SharedModels;
 
 namespace Flow.Launcher.Plugin.BrowserBookmark.Commands
 {

Plugins/Flow.Launcher.Plugin.BrowserBookmark/Flow.Launcher.Plugin.BrowserBookmark.csproj

@@ -1,9 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
-	<UseWPF>true</UseWPF>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{9B130CC5-14FB-41FF-B310-0A95B6894C37}</ProjectGuid>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Flow.Launcher.Plugin.BrowserBookmark</RootNamespace>
@@ -64,7 +63,14 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
   </ItemGroup>
-	
+  
+  <ItemGroup>
+    <Page Include="Views\SettingsControl.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="System.Data.SQLite" Version="1.0.112" />
     <PackageReference Include="System.Data.SQLite.Core" Version="1.0.112" />

Plugins/Flow.Launcher.Plugin.Calculator/Flow.Launcher.Plugin.Calculator.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{59BD9891-3837-438A-958D-ADC7F91F6F7E}</ProjectGuid>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Flow.Launcher.Plugin.Caculator</RootNamespace>

Plugins/Flow.Launcher.Plugin.Calculator/Languages/sk.xaml

@@ -6,7 +6,7 @@
     <system:String x:Key="flowlauncher_plugin_caculator_plugin_description">Spracúva matematické operácie.(Skúste 5*3-2 vo flowlauncheri)</system:String>
     <system:String x:Key="flowlauncher_plugin_calculator_not_a_number">Nie je číslo (NaN)</system:String>
     <system:String x:Key="flowlauncher_plugin_calculator_expression_not_complete">Nesprávny alebo neúplný výraz (Nezabudli ste na zátvorky?)</system:String>
-    <system:String x:Key="flowlauncher_plugin_calculator_copy_number_to_clipboard">Kopírovať toto číslo do schránky</system:String>
+    <system:String x:Key="flowlauncher_plugin_calculator_copy_number_to_clipboard">Kopírovať výsledok do schránky</system:String>
     <system:String x:Key="flowlauncher_plugin_calculator_output_decimal_seperator">Oddeľovač des. miest</system:String>
     <system:String x:Key="flowlauncher_plugin_calculator_output_decimal_seperator_help">Oddeľovač desatinných miest použitý vo výsledku.</system:String>
     <system:String x:Key="flowlauncher_plugin_calculator_decimal_seperator_use_system_locale">Použiť podľa systému</system:String>

Plugins/Flow.Launcher.Plugin.Calculator/Main.cs

@@ -91,7 +91,7 @@ namespace Flow.Launcher.Plugin.Caculator
                     };
                 }
             }
-            catch
+            catch (Exception)
             {
                 // ignored
             }

Plugins/Flow.Launcher.Plugin.ControlPanel/ControlPanelList.cs

@@ -38,7 +38,7 @@ namespace Flow.Launcher.Plugin.ControlPanel
         int cxDesired, int cyDesired, uint fuLoad);
 
         [DllImport("user32.dll", CharSet = CharSet.Auto)]
-        extern static bool DestroyIcon(IntPtr handle);
+        static extern bool DestroyIcon(IntPtr handle);
 
         [DllImport("kernel32.dll")]
         static extern IntPtr FindResource(IntPtr hModule, IntPtr lpName, IntPtr lpType);

Plugins/Flow.Launcher.Plugin.ControlPanel/Flow.Launcher.Plugin.ControlPanel.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{1EE20B48-82FB-48A2-8086-675D6DDAB4F0}</ProjectGuid>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Flow.Launcher.Plugin.ControlPanel</RootNamespace>

Plugins/Flow.Launcher.Plugin.Explorer/ContextMenu.cs

@@ -7,12 +7,13 @@ using System.Windows;
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Plugin.SharedCommands;
 using Flow.Launcher.Plugin.Explorer.Search;
-using Flow.Launcher.Plugin.Explorer.Search.FolderLinks;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
 using System.Linq;
 using MessageBox = System.Windows.Forms.MessageBox;
 using MessageBoxIcon = System.Windows.Forms.MessageBoxIcon;
 using MessageBoxButton = System.Windows.Forms.MessageBoxButtons;
 using DialogResult = System.Windows.Forms.DialogResult;
+using Flow.Launcher.Plugin.Explorer.ViewModels;
 
 namespace Flow.Launcher.Plugin.Explorer
 {
@@ -22,10 +23,13 @@ namespace Flow.Launcher.Plugin.Explorer
 
         private Settings Settings { get; set; }
 
-        public ContextMenu(PluginInitContext context, Settings settings)
+        private SettingsViewModel ViewModel { get; set; }
+
+        public ContextMenu(PluginInitContext context, Settings settings, SettingsViewModel vm)
         {
             Context = context;
             Settings = settings;
+            ViewModel = vm;
         }
 
         public List<Result> LoadContextMenus(Result selectedResult)
@@ -50,6 +54,58 @@ namespace Flow.Launcher.Plugin.Explorer
 
                 var icoPath = (record.Type == ResultType.File) ? Constants.FileImagePath : Constants.FolderImagePath;
                 var fileOrFolder = (record.Type == ResultType.File) ? "file" : "folder";
+
+                if (!Settings.QuickAccessLinks.Any(x => x.Path == record.FullPath))
+                {
+                    contextMenus.Add(new Result
+                    {
+                        Title = Context.API.GetTranslation("plugin_explorer_add_to_quickaccess_title"),
+                        SubTitle = string.Format(Context.API.GetTranslation("plugin_explorer_add_to_quickaccess_subtitle"), fileOrFolder),
+                        Action = (context) =>
+                        {
+                            Settings.QuickAccessLinks.Add(new AccessLink { Path = record.FullPath, Type = record.Type });
+
+                            Context.API.ShowMsg(Context.API.GetTranslation("plugin_explorer_addfilefoldersuccess"),
+                                                                        string.Format(
+                                                                            Context.API.GetTranslation("plugin_explorer_addfilefoldersuccess_detail"),
+                                                                                fileOrFolder),
+                                                                            Constants.ExplorerIconImageFullPath);
+
+                            ViewModel.Save();
+
+                            return true;
+                        },
+                        SubTitleToolTip = Context.API.GetTranslation("plugin_explorer_contextmenu_titletooltip"),
+                        TitleToolTip = Context.API.GetTranslation("plugin_explorer_contextmenu_titletooltip"),
+                        IcoPath = Constants.QuickAccessImagePath
+                    });
+                }
+                else
+                {
+                    contextMenus.Add(new Result
+                    {
+                        Title = Context.API.GetTranslation("plugin_explorer_remove_from_quickaccess_title"),
+                        SubTitle = string.Format(Context.API.GetTranslation("plugin_explorer_remove_from_quickaccess_subtitle"), fileOrFolder),
+                        Action = (context) =>
+                        {
+                            Settings.QuickAccessLinks.Remove(Settings.QuickAccessLinks.FirstOrDefault(x => x.Path == record.FullPath));
+
+                            Context.API.ShowMsg(Context.API.GetTranslation("plugin_explorer_removefilefoldersuccess"),
+                                                                        string.Format(
+                                                                            Context.API.GetTranslation("plugin_explorer_removefilefoldersuccess_detail"),
+                                                                                fileOrFolder),
+                                                                            Constants.ExplorerIconImageFullPath);
+
+                            ViewModel.Save();
+
+                            return true;
+                        },
+                        SubTitleToolTip = Context.API.GetTranslation("plugin_explorer_contextmenu_remove_titletooltip"),
+                        TitleToolTip = Context.API.GetTranslation("plugin_explorer_contextmenu_remove_titletooltip"),
+                        IcoPath = Constants.RemoveQuickAccessImagePath
+                    });
+                }
+                
                 contextMenus.Add(new Result
                 {
                     Title = Context.API.GetTranslation("plugin_explorer_copypath"),
@@ -228,7 +284,7 @@ namespace Flow.Launcher.Plugin.Explorer
                 Action = _ =>
                 {
                     if(!Settings.IndexSearchExcludedSubdirectoryPaths.Any(x => x.Path == record.FullPath))
-                        Settings.IndexSearchExcludedSubdirectoryPaths.Add(new FolderLink { Path = record.FullPath });
+                        Settings.IndexSearchExcludedSubdirectoryPaths.Add(new AccessLink { Path = record.FullPath });
 
                     Task.Run(() =>
                     {

Plugins/Flow.Launcher.Plugin.Explorer/Flow.Launcher.Plugin.Explorer.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>

Plugins/Flow.Launcher.Plugin.Explorer/Languages/en.xaml

@@ -16,7 +16,7 @@
     <system:String x:Key="plugin_explorer_edit">Edit</system:String>
     <system:String x:Key="plugin_explorer_add">Add</system:String>
     <system:String x:Key="plugin_explorer_manageactionkeywords_header">Customise Action Keywords</system:String>
-    <system:String x:Key="plugin_explorer_quickfolderaccess_header">Quick Folder Access Paths</system:String>
+    <system:String x:Key="plugin_explorer_quickaccesslinks_header">Quick Access Links</system:String>
     <system:String x:Key="plugin_explorer_indexsearchexcludedpaths_header">Index Search Excluded Paths</system:String>
     <system:String x:Key="plugin_explorer_manageindexoptions">Indexing Options</system:String>
     <system:String x:Key="plugin_explorer_actionkeywordview_search">Search Activation:</system:String>
@@ -42,5 +42,15 @@
     <system:String x:Key="plugin_explorer_openindexingoptions">Open Windows Indexing Options</system:String>
     <system:String x:Key="plugin_explorer_openindexingoptions_subtitle">Manage indexed files and folders</system:String>
     <system:String x:Key="plugin_explorer_openindexingoptions_errormsg">Failed to open Windows Indexing Options</system:String>
+    <system:String x:Key="plugin_explorer_add_to_quickaccess_title">Add to Quick Access</system:String>
+    <system:String x:Key="plugin_explorer_add_to_quickaccess_subtitle">Add the current {0} to Quick Access</system:String>
+    <system:String x:Key="plugin_explorer_addfilefoldersuccess">Successfully Added</system:String>
+    <system:String x:Key="plugin_explorer_addfilefoldersuccess_detail">Successfully added to Quick Access</system:String>
+    <system:String x:Key="plugin_explorer_removefilefoldersuccess">Successfully Removed</system:String>
+    <system:String x:Key="plugin_explorer_removefilefoldersuccess_detail">Successfully removed from Quick Access</system:String>
+    <system:String x:Key="plugin_explorer_contextmenu_titletooltip">Add to Quick Access so it can be opened with Explorer's Search Activation action keyword</system:String>
+    <system:String x:Key="plugin_explorer_contextmenu_remove_titletooltip">Remove from Quick Access</system:String>
+    <system:String x:Key="plugin_explorer_remove_from_quickaccess_title">Remove from Quick Access</system:String>
+    <system:String x:Key="plugin_explorer_remove_from_quickaccess_subtitle">Remove the current {0} from Quick Access</system:String>
 
 </ResourceDictionary>

Plugins/Flow.Launcher.Plugin.Explorer/Main.cs

@@ -1,13 +1,17 @@
 using Flow.Launcher.Infrastructure.Storage;
 using Flow.Launcher.Plugin.Explorer.Search;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
 using Flow.Launcher.Plugin.Explorer.ViewModels;
 using Flow.Launcher.Plugin.Explorer.Views;
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Windows.Controls;
 
 namespace Flow.Launcher.Plugin.Explorer
 {
-    public class Main : ISettingProvider, IPlugin, ISavable, IContextMenu, IPluginI18n
+    public class Main : ISettingProvider, IAsyncPlugin, ISavable, IContextMenu, IPluginI18n
     {
         internal PluginInitContext Context { get; set; }
 
@@ -17,17 +21,30 @@ namespace Flow.Launcher.Plugin.Explorer
 
         private IContextMenu contextMenu;
 
+        private SearchManager searchManager;
+
         public Control CreateSettingPanel()
         {
             return new ExplorerSettings(viewModel);
         }
 
-        public void Init(PluginInitContext context)
+        public async Task InitAsync(PluginInitContext context)
         {
             Context = context;
             viewModel = new SettingsViewModel(context);
+            await viewModel.LoadStorage();
             Settings = viewModel.Settings;
-            contextMenu = new ContextMenu(Context, Settings);
+
+            // as at v1.7.0 this is to maintain backwards compatibility, need to be removed afterwards.
+            if (Settings.QuickFolderAccessLinks.Any())
+            {
+                Settings.QuickAccessLinks = Settings.QuickFolderAccessLinks;
+                Settings.QuickFolderAccessLinks = new List<AccessLink>();
+            }
+
+            contextMenu = new ContextMenu(Context, Settings, viewModel);
+            searchManager = new SearchManager(Settings, Context);
+            ResultManager.Init(Context);
         }
 
         public List<Result> LoadContextMenus(Result selectedResult)
@@ -35,9 +52,9 @@ namespace Flow.Launcher.Plugin.Explorer
             return contextMenu.LoadContextMenus(selectedResult);
         }
 
-        public List<Result> Query(Query query)
+        public async Task<List<Result>> QueryAsync(Query query, CancellationToken token)
         {
-            return new SearchManager(Settings, Context).Search(query);
+            return await searchManager.SearchAsync(query, token);
         }
 
         public void Save()

Plugins/Flow.Launcher.Plugin.Explorer/Search/Constants.cs

@@ -15,6 +15,8 @@ namespace Flow.Launcher.Plugin.Explorer.Search
         internal const string ExplorerIconImagePath = "Images\\explorer.png";
         internal const string DifferentUserIconImagePath = "Images\\user.png";
         internal const string IndexingOptionsIconImagePath = "Images\\windowsindexingoptions.png";
+        internal const string QuickAccessImagePath = "Images\\quickaccess.png";
+        internal const string RemoveQuickAccessImagePath = "Images\\removequickaccess.png";
 
         internal const string ToolTipOpenDirectory = "Ctrl + Enter to open the directory";
 

Plugins/Flow.Launcher.Plugin.Explorer/Search/DirectoryInfo/DirectoryInfoSearch.cs

@@ -4,29 +4,27 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 
 namespace Flow.Launcher.Plugin.Explorer.Search.DirectoryInfo
 {
-    public class DirectoryInfoSearch
+    public static class DirectoryInfoSearch
     {
-        private readonly ResultManager resultManager;
-
-        public DirectoryInfoSearch(PluginInitContext context)
-        {
-            resultManager = new ResultManager(context);
-        }
-
-        internal List<Result> TopLevelDirectorySearch(Query query, string search)
+        internal static List<Result> TopLevelDirectorySearch(Query query, string search, CancellationToken token)
         {
             var criteria = ConstructSearchCriteria(search);
 
-            if (search.LastIndexOf(Constants.AllFilesFolderSearchWildcard) > search.LastIndexOf(Constants.DirectorySeperator))
-                return DirectorySearch(SearchOption.AllDirectories, query, search, criteria);
-            
-            return DirectorySearch(SearchOption.TopDirectoryOnly, query, search, criteria);
+            if (search.LastIndexOf(Constants.AllFilesFolderSearchWildcard) >
+                search.LastIndexOf(Constants.DirectorySeperator))
+                return DirectorySearch(new EnumerationOptions
+                {
+                    RecurseSubdirectories = true
+                }, query, search, criteria, token);
+
+            return DirectorySearch(new EnumerationOptions(), query, search, criteria, token); // null will be passed as default
         }
 
-        public string ConstructSearchCriteria(string search)
+        public static string ConstructSearchCriteria(string search)
         {
             string incompleteName = "";
 
@@ -45,7 +43,8 @@ namespace Flow.Launcher.Plugin.Explorer.Search.DirectoryInfo
             return incompleteName;
         }
 
-        private List<Result> DirectorySearch(SearchOption searchOption, Query query, string search, string searchCriteria)
+        private static List<Result> DirectorySearch(EnumerationOptions enumerationOption, Query query, string search,
+            string searchCriteria, CancellationToken token)
         {
             var results = new List<Result>();
 
@@ -57,40 +56,39 @@ namespace Flow.Launcher.Plugin.Explorer.Search.DirectoryInfo
             try
             {
                 var directoryInfo = new System.IO.DirectoryInfo(path);
-                var fileSystemInfos = directoryInfo.GetFileSystemInfos(searchCriteria, searchOption);
 
-                foreach (var fileSystemInfo in fileSystemInfos)
+                foreach (var fileSystemInfo in directoryInfo.EnumerateFileSystemInfos(searchCriteria, enumerationOption))
                 {
-                    if ((fileSystemInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden) continue;
-
                     if (fileSystemInfo is System.IO.DirectoryInfo)
                     {
-                        folderList.Add(resultManager.CreateFolderResult(fileSystemInfo.Name, fileSystemInfo.FullName, fileSystemInfo.FullName, query, true, false));
+                        folderList.Add(ResultManager.CreateFolderResult(fileSystemInfo.Name, fileSystemInfo.FullName,
+                            fileSystemInfo.FullName, query, true, false));
                     }
                     else
                     {
-                        fileList.Add(resultManager.CreateFileResult(fileSystemInfo.FullName, query, true, false));
+                        fileList.Add(ResultManager.CreateFileResult(fileSystemInfo.FullName, query, true, false));
                     }
+
+                    token.ThrowIfCancellationRequested();
                 }
             }
             catch (Exception e)
             {
-                if (e is UnauthorizedAccessException || e is ArgumentException)
-                {
-                    results.Add(new Result { Title = e.Message, Score = 501 });
+                if (!(e is ArgumentException))
+                    throw e;
+                
+                results.Add(new Result {Title = e.Message, Score = 501});
 
-                    return results;
-                }
+                return results;
 
 #if DEBUG // Please investigate and handle error from DirectoryInfo search
-                throw e;
 #else
                 Log.Exception($"|Flow.Launcher.Plugin.Explorer.DirectoryInfoSearch|Error from performing DirectoryInfoSearch", e);
-#endif          
+#endif
             }
 
-            // Intial ordering, this order can be updated later by UpdateResultView.MainViewModel based on history of user selection.
+            // Initial ordering, this order can be updated later by UpdateResultView.MainViewModel based on history of user selection.
             return results.Concat(folderList.OrderBy(x => x.Title)).Concat(fileList.OrderBy(x => x.Title)).ToList();
         }
     }
-}
+}

Plugins/Flow.Launcher.Plugin.Explorer/Search/EnvironmentVariables.cs

@@ -76,7 +76,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
                 {
                     var expandedPath = environmentVariables[search];
                    
-                    results.Add(new ResultManager(context).CreateFolderResult($"%{search}%", expandedPath, expandedPath, query));
+                    results.Add(ResultManager.CreateFolderResult($"%{search}%", expandedPath, expandedPath, query));
                     
                     return results;
                 }
@@ -95,7 +95,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
             {
                 if (p.Key.StartsWith(search, StringComparison.InvariantCultureIgnoreCase))
                 {
-                    results.Add(new ResultManager(context).CreateFolderResult($"%{p.Key}%", p.Value, p.Value, query));
+                    results.Add(ResultManager.CreateFolderResult($"%{p.Key}%", p.Value, p.Value, query));
                 }
             }
 

Plugins/Flow.Launcher.Plugin.Explorer/Search/FolderLinks/QuickFolderAccess.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Flow.Launcher.Plugin.Explorer.Search.FolderLinks
-{
-    public class QuickFolderAccess
-    {
-        internal List<Result> FolderListMatched(Query query, List<FolderLink> folderLinks, PluginInitContext context)
-        {
-            if (string.IsNullOrEmpty(query.Search))
-                return new List<Result>();
-
-            string search = query.Search.ToLower();
-            
-            var queriedFolderLinks = folderLinks.Where(x => x.Nickname.StartsWith(search, StringComparison.OrdinalIgnoreCase));
-
-            return queriedFolderLinks.Select(item =>
-                                                new ResultManager(context)
-                                                        .CreateFolderResult(item.Nickname, item.Path, item.Path, query))
-                                     .ToList();
-        }
-
-        internal List<Result> FolderListAll(Query query, List<FolderLink> folderLinks, PluginInitContext context)
-            => folderLinks
-                .Select(item => 
-                            new ResultManager(context).CreateFolderResult(item.Nickname, item.Path, item.Path, query))
-                .ToList();
-    }
-}

Plugins/Flow.Launcher.Plugin.Explorer/Search/QuickAccessLinks/AccessLink.cs

@@ -1,14 +1,15 @@
 using System;
 using System.Linq;
-using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace Flow.Launcher.Plugin.Explorer.Search.FolderLinks
+namespace Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks
 {
-    public class FolderLink
+    public class AccessLink
     {
         public string Path { get; set; }
 
+        public ResultType Type { get; set; } = ResultType.Folder;
+
         [JsonIgnore]
         public string Nickname
         {

Plugins/Flow.Launcher.Plugin.Explorer/Search/QuickAccessLinks/QuickAccess.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks
+{
+    internal static class QuickAccess
+    {
+        internal static List<Result> AccessLinkListMatched(Query query, List<AccessLink> accessLinks)
+        {
+            if (string.IsNullOrEmpty(query.Search))
+                return new List<Result>();
+
+            string search = query.Search.ToLower();
+
+            var queriedAccessLinks =
+                accessLinks
+                .Where(x => x.Nickname.StartsWith(search, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(x => x.Type)
+                .ThenBy(x => x.Nickname);
+
+            return queriedAccessLinks.Select(l => l.Type switch
+            {
+                ResultType.Folder => ResultManager.CreateFolderResult(l.Nickname, l.Path, l.Path, query),
+                ResultType.File => ResultManager.CreateFileResult(l.Path, query),
+                _ => throw new ArgumentOutOfRangeException()
+
+            }).ToList();
+        }
+
+        internal static List<Result> AccessLinkListAll(Query query, List<AccessLink> accessLinks)
+            => accessLinks
+                .OrderBy(x => x.Type)
+                .ThenBy(x => x.Nickname)
+                .Select(l => l.Type switch
+                {
+                    ResultType.Folder => ResultManager.CreateFolderResult(l.Nickname, l.Path, l.Path, query),
+                    ResultType.File => ResultManager.CreateFileResult(l.Path, query),
+                    _ => throw new ArgumentOutOfRangeException()
+
+                }).ToList();
+    }
+}

Plugins/Flow.Launcher.Plugin.Explorer/Search/ResultManager.cs

@@ -1,22 +1,22 @@
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Plugin.SharedCommands;
 using System;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Windows;
 
 namespace Flow.Launcher.Plugin.Explorer.Search
 {
-    public class ResultManager
+    public static class ResultManager
     {
-        private readonly PluginInitContext context;
+        private static PluginInitContext Context;
 
-        public ResultManager(PluginInitContext context)
+        public static void Init(PluginInitContext context)
         {
-            this.context = context;
+            Context = context;
         }
-        internal Result CreateFolderResult(string title, string subtitle, string path, Query query, bool showIndexState = false, bool windowsIndexed = false)
+
+        internal static Result CreateFolderResult(string title, string subtitle, string path, Query query, bool showIndexState = false, bool windowsIndexed = false)
         {
             return new Result
             {
@@ -41,7 +41,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
                     }
 
                     string changeTo = path.EndsWith(Constants.DirectorySeperator) ? path : path + Constants.DirectorySeperator;
-                    context.API.ChangeQuery(string.IsNullOrEmpty(query.ActionKeyword) ?
+                    Context.API.ChangeQuery(string.IsNullOrEmpty(query.ActionKeyword) ?
                         changeTo :
                         query.ActionKeyword + " " + changeTo);
                     return false;
@@ -52,7 +52,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
             };
         }
 
-        internal Result CreateOpenCurrentFolderResult(string path, bool windowsIndexed = false)
+        internal static Result CreateOpenCurrentFolderResult(string path, bool windowsIndexed = false)
         {
             var retrievedDirectoryPath = FilesFolders.ReturnPreviousDirectoryIfIncompleteString(path);
 
@@ -94,7 +94,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
             };
         }
 
-        internal Result CreateFileResult(string filePath, Query query, bool showIndexState = false, bool windowsIndexed = false)
+        internal static Result CreateFileResult(string filePath, Query query, bool showIndexState = false, bool windowsIndexed = false)
         {
             var result = new Result
             {
@@ -140,7 +140,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
         public bool ShowIndexState { get; set; }
     }
 
-    internal enum ResultType
+    public enum ResultType
     {
         Volume,
         Folder,

Plugins/Flow.Launcher.Plugin.Explorer/Search/SearchManager.cs

@@ -1,10 +1,12 @@
 using Flow.Launcher.Plugin.Explorer.Search.DirectoryInfo;
-using Flow.Launcher.Plugin.Explorer.Search.FolderLinks;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
 using Flow.Launcher.Plugin.Explorer.Search.WindowsIndex;
 using Flow.Launcher.Plugin.SharedCommands;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Plugin.Explorer.Search
 {
@@ -12,41 +14,31 @@ namespace Flow.Launcher.Plugin.Explorer.Search
     {
         private readonly PluginInitContext context;
 
-        private readonly IndexSearch indexSearch;
-
-        private readonly QuickFolderAccess quickFolderAccess = new QuickFolderAccess();
-
-        private readonly ResultManager resultManager;
-
         private readonly Settings settings;
 
         public SearchManager(Settings settings, PluginInitContext context)
         {
             this.context = context;
-            indexSearch = new IndexSearch(context);
-            resultManager = new ResultManager(context);
             this.settings = settings;
         }
 
-        internal List<Result> Search(Query query)
+        internal async Task<List<Result>> SearchAsync(Query query, CancellationToken token)
         {
             var results = new List<Result>();
 
             var querySearch = query.Search;
 
             if (IsFileContentSearch(query.ActionKeyword))
-                return WindowsIndexFileContentSearch(query, querySearch);
+                return await WindowsIndexFileContentSearchAsync(query, querySearch, token).ConfigureAwait(false);
 
             // This allows the user to type the assigned action keyword and only see the list of quick folder links
-            if (settings.QuickFolderAccessLinks.Count > 0
-                && query.ActionKeyword == settings.SearchActionKeyword
-                && string.IsNullOrEmpty(query.Search))
-                    return quickFolderAccess.FolderListAll(query, settings.QuickFolderAccessLinks, context);
+            if (string.IsNullOrEmpty(query.Search))
+                return QuickAccess.AccessLinkListAll(query, settings.QuickAccessLinks);
 
-            var quickFolderLinks = quickFolderAccess.FolderListMatched(query, settings.QuickFolderAccessLinks, context);
+            var quickaccessLinks = QuickAccess.AccessLinkListMatched(query, settings.QuickAccessLinks);
 
-            if (quickFolderLinks.Count > 0)
-                results.AddRange(quickFolderLinks);
+            if (quickaccessLinks.Count > 0)
+                results.AddRange(quickaccessLinks);
 
             var isEnvironmentVariable = EnvironmentVariables.IsEnvironmentVariableSearch(querySearch);
 
@@ -54,11 +46,11 @@ namespace Flow.Launcher.Plugin.Explorer.Search
                 return EnvironmentVariables.GetEnvironmentStringPathSuggestions(querySearch, query, context);
 
             // Query is a location path with a full environment variable, eg. %appdata%\somefolder\
-            var isEnvironmentVariablePath = querySearch.Substring(1).Contains("%\\");
+            var isEnvironmentVariablePath = querySearch[1..].Contains("%\\");
 
-            if (!FilesFolders.IsLocationPathString(querySearch) && !isEnvironmentVariablePath)
+            if (!querySearch.IsLocationPathString() && !isEnvironmentVariablePath)
             {
-                results.AddRange(WindowsIndexFilesAndFoldersSearch(query, querySearch));
+                results.AddRange(await WindowsIndexFilesAndFoldersSearchAsync(query, querySearch, token).ConfigureAwait(false));
 
                 return results;
             }
@@ -68,33 +60,42 @@ namespace Flow.Launcher.Plugin.Explorer.Search
             if (isEnvironmentVariablePath)
                 locationPath = EnvironmentVariables.TranslateEnvironmentVariablePath(locationPath);
 
+            // Check that actual location exists, otherwise directory search will throw directory not found exception
             if (!FilesFolders.LocationExists(FilesFolders.ReturnPreviousDirectoryIfIncompleteString(locationPath)))
                 return results;
 
             var useIndexSearch = UseWindowsIndexForDirectorySearch(locationPath);
-            
-            results.Add(resultManager.CreateOpenCurrentFolderResult(locationPath, useIndexSearch));
 
-            results.AddRange(TopLevelDirectorySearchBehaviour(WindowsIndexTopLevelFolderSearch,
-                                                                DirectoryInfoClassSearch,
-                                                                useIndexSearch,
-                                                                query,
-                                                                locationPath));
+            results.Add(ResultManager.CreateOpenCurrentFolderResult(locationPath, useIndexSearch));
+
+            token.ThrowIfCancellationRequested();
+
+            var directoryResult = await TopLevelDirectorySearchBehaviourAsync(WindowsIndexTopLevelFolderSearchAsync,
+                DirectoryInfoClassSearch,
+                useIndexSearch,
+                query,
+                locationPath,
+                token).ConfigureAwait(false);
+
+            token.ThrowIfCancellationRequested();
+
+            results.AddRange(directoryResult);
 
             return results;
         }
 
-        private List<Result> WindowsIndexFileContentSearch(Query query, string querySearchString)
+        private async Task<List<Result>> WindowsIndexFileContentSearchAsync(Query query, string querySearchString, CancellationToken token)
         {
             var queryConstructor = new QueryConstructor(settings);
 
             if (string.IsNullOrEmpty(querySearchString))
                 return new List<Result>();
 
-            return indexSearch.WindowsIndexSearch(querySearchString,
+            return await IndexSearch.WindowsIndexSearchAsync(querySearchString,
                                                     queryConstructor.CreateQueryHelper().ConnectionString,
                                                     queryConstructor.QueryForFileContentSearch,
-                                                    query);
+                                                    query,
+                                                    token).ConfigureAwait(false);
         }
 
         public bool IsFileContentSearch(string actionKeyword)
@@ -102,44 +103,45 @@ namespace Flow.Launcher.Plugin.Explorer.Search
             return actionKeyword == settings.FileContentSearchActionKeyword;
         }
 
-        private List<Result> DirectoryInfoClassSearch(Query query, string querySearch)
+        private List<Result> DirectoryInfoClassSearch(Query query, string querySearch, CancellationToken token)
         {
-            var directoryInfoSearch = new DirectoryInfoSearch(context);
-
-            return directoryInfoSearch.TopLevelDirectorySearch(query, querySearch);
+            return DirectoryInfoSearch.TopLevelDirectorySearch(query, querySearch, token);
         }
 
-        public List<Result> TopLevelDirectorySearchBehaviour(
-            Func<Query, string, List<Result>> windowsIndexSearch,
-            Func<Query, string, List<Result>> directoryInfoClassSearch,
+        public async Task<List<Result>> TopLevelDirectorySearchBehaviourAsync(
+            Func<Query, string, CancellationToken, Task<List<Result>>> windowsIndexSearch,
+            Func<Query, string, CancellationToken, List<Result>> directoryInfoClassSearch,
             bool useIndexSearch,
             Query query,
-            string querySearchString)
+            string querySearchString,
+            CancellationToken token)
         {
             if (!useIndexSearch)
-                return directoryInfoClassSearch(query, querySearchString);
+                return directoryInfoClassSearch(query, querySearchString, token);
 
-            return windowsIndexSearch(query, querySearchString);
+            return await windowsIndexSearch(query, querySearchString, token);
         }
 
-        private List<Result> WindowsIndexFilesAndFoldersSearch(Query query, string querySearchString)
+        private async Task<List<Result>> WindowsIndexFilesAndFoldersSearchAsync(Query query, string querySearchString, CancellationToken token)
         {
             var queryConstructor = new QueryConstructor(settings);
 
-            return indexSearch.WindowsIndexSearch(querySearchString,
+            return await IndexSearch.WindowsIndexSearchAsync(querySearchString,
                                                    queryConstructor.CreateQueryHelper().ConnectionString,
                                                    queryConstructor.QueryForAllFilesAndFolders,
-                                                   query);
+                                                   query,
+                                                   token).ConfigureAwait(false);
         }
-        
-        private List<Result> WindowsIndexTopLevelFolderSearch(Query query, string path)
+
+        private async Task<List<Result>> WindowsIndexTopLevelFolderSearchAsync(Query query, string path, CancellationToken token)
         {
             var queryConstructor = new QueryConstructor(settings);
 
-            return indexSearch.WindowsIndexSearch(path,
+            return await IndexSearch.WindowsIndexSearchAsync(path,
                                                    queryConstructor.CreateQueryHelper().ConnectionString,
                                                    queryConstructor.QueryForTopLevelDirectorySearch,
-                                                   query);
+                                                   query,
+                                                   token).ConfigureAwait(false);
         }
 
         private bool UseWindowsIndexForDirectorySearch(string locationPath)
@@ -154,7 +156,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search
                                         .StartsWith(x.Path, StringComparison.OrdinalIgnoreCase)))
                 return false;
 
-            return indexSearch.PathIsIndexed(pathToDirectory);
+            return IndexSearch.PathIsIndexed(pathToDirectory);
         }
     }
 }

Plugins/Flow.Launcher.Plugin.Explorer/Search/WindowsIndex/IndexSearch.cs

@@ -1,82 +1,71 @@
-using Flow.Launcher.Infrastructure.Logger;
+using Flow.Launcher.Infrastructure.Logger;
 using Microsoft.Search.Interop;
 using System;
 using System.Collections.Generic;
 using System.Data.OleDb;
 using System.Linq;
 using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
 {
-    internal class IndexSearch
+    internal static class IndexSearch
     {
-        private readonly object _lock = new object();
-
-        private OleDbConnection conn;
-
-        private OleDbCommand command;
-        
-        private OleDbDataReader dataReaderResults;
-
-        private readonly ResultManager resultManager;
 
         // Reserved keywords in oleDB
-        private readonly string reservedStringPattern = @"^[\/\\\$\%_]+$";
+        private const string reservedStringPattern = @"^[`\@\#\^,\&\/\\\$\%_]+$";
 
-        internal IndexSearch(PluginInitContext context)
+        internal async static Task<List<Result>> ExecuteWindowsIndexSearchAsync(string indexQueryString, string connectionString, Query query, CancellationToken token)
         {
-            resultManager = new ResultManager(context);
-        }
-
-        internal List<Result> ExecuteWindowsIndexSearch(string indexQueryString, string connectionString, Query query)
-        {
-            var folderResults = new List<Result>();
-            var fileResults = new List<Result>();
             var results = new List<Result>();
+            var fileResults = new List<Result>();
 
             try
             {
-                using (conn = new OleDbConnection(connectionString))
+                using var conn = new OleDbConnection(connectionString);
+                await conn.OpenAsync(token);
+                token.ThrowIfCancellationRequested();
+
+                using var command = new OleDbCommand(indexQueryString, conn);
+                // Results return as an OleDbDataReader.
+                using var dataReaderResults = await command.ExecuteReaderAsync(token) as OleDbDataReader;
+                token.ThrowIfCancellationRequested();
+
+                if (dataReaderResults.HasRows)
                 {
-                    conn.Open();
-
-                    using (command = new OleDbCommand(indexQueryString, conn))
+                    while (await dataReaderResults.ReadAsync(token))
                     {
-                        // Results return as an OleDbDataReader.
-                        using (dataReaderResults = command.ExecuteReader())
+                        token.ThrowIfCancellationRequested();
+                        if (dataReaderResults.GetValue(0) != DBNull.Value && dataReaderResults.GetValue(1) != DBNull.Value)
                         {
-                            if (dataReaderResults.HasRows)
-                            {
-                                while (dataReaderResults.Read())
-                                {
-                                    if (dataReaderResults.GetValue(0) != DBNull.Value && dataReaderResults.GetValue(1) != DBNull.Value)
-                                    {
-                                        // # is URI syntax for the fragment component, need to be encoded so LocalPath returns complete path   
-                                        var encodedFragmentPath = dataReaderResults
-                                                                    .GetString(1)
-                                                                    .Replace("#", "%23", StringComparison.OrdinalIgnoreCase);
-                                        
-                                        var path = new Uri(encodedFragmentPath).LocalPath;
+                            // # is URI syntax for the fragment component, need to be encoded so LocalPath returns complete path   
+                            var encodedFragmentPath = dataReaderResults
+                                                        .GetString(1)
+                                                        .Replace("#", "%23", StringComparison.OrdinalIgnoreCase);
 
-                                        if (dataReaderResults.GetString(2) == "Directory")
-                                        {
-                                            folderResults.Add(resultManager.CreateFolderResult(
-                                                                                dataReaderResults.GetString(0),
-                                                                                path,
-                                                                                path, 
-                                                                                query, true, true));
-                                        }
-                                        else
-                                        {
-                                            fileResults.Add(resultManager.CreateFileResult(path, query, true, true));
-                                        }
-                                    }
-                                }
+                            var path = new Uri(encodedFragmentPath).LocalPath;
+
+                            if (dataReaderResults.GetString(2) == "Directory")
+                            {
+                                results.Add(ResultManager.CreateFolderResult(
+                                                                    dataReaderResults.GetString(0),
+                                                                    path,
+                                                                    path,
+                                                                    query, true, true));
+                            }
+                            else
+                            {
+                                fileResults.Add(ResultManager.CreateFileResult(path, query, true, true));
                             }
                         }
                     }
                 }
             }
+            catch (OperationCanceledException)
+            {
+                return new List<Result>(); // The source code indicates that without adding members, it won't allocate an array
+            }
             catch (InvalidOperationException e)
             {
                 // Internal error from ExecuteReader(): Connection closed.
@@ -87,32 +76,34 @@ namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
                 LogException("General error from performing index search", e);
             }
 
+            results.AddRange(fileResults);
+
             // Intial ordering, this order can be updated later by UpdateResultView.MainViewModel based on history of user selection.
-            return results.Concat(folderResults.OrderBy(x => x.Title)).Concat(fileResults.OrderBy(x => x.Title)).ToList(); ;
+             return results;
         }
 
-        internal List<Result> WindowsIndexSearch(string searchString, string connectionString, Func<string, string> constructQuery, Query query)
+        internal async static Task<List<Result>> WindowsIndexSearchAsync(string searchString, string connectionString,
+                                                                  Func<string, string> constructQuery, Query query,
+                                                                  CancellationToken token)
         {
             var regexMatch = Regex.Match(searchString, reservedStringPattern);
 
             if (regexMatch.Success)
                 return new List<Result>();
 
-            lock (_lock)
-            {
-                var constructedQuery = constructQuery(searchString);
-                return ExecuteWindowsIndexSearch(constructedQuery, connectionString, query);
-            }
+            var constructedQuery = constructQuery(searchString);
+            return await ExecuteWindowsIndexSearchAsync(constructedQuery, connectionString, query, token);
+
         }
 
-        internal bool PathIsIndexed(string path)
+        internal static bool PathIsIndexed(string path)
         {
             var csm = new CSearchManager();
             var indexManager = csm.GetCatalog("SystemIndex").GetCrawlScopeManager();
             return indexManager.IncludedInCrawlScope(path) > 0;
         }
 
-        private void LogException(string message, Exception e)
+        private static void LogException(string message, Exception e)
         {
 #if DEBUG // Please investigate and handle error from index search
             throw e;

Plugins/Flow.Launcher.Plugin.Explorer/Search/WindowsIndex/QueryConstructor.cs

@@ -42,7 +42,7 @@ namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
 
             // Get the ISearchQueryHelper which will help us to translate AQS --> SQL necessary to query the indexer
             var queryHelper = catalogManager.GetQueryHelper();
-
+            
             return queryHelper;
         }
 
@@ -81,11 +81,9 @@ namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
             var previousLevelDirectory = path.Substring(0, indexOfSeparator);
 
             if (string.IsNullOrEmpty(itemName))
-                return searchDepth + $"{previousLevelDirectory}'";
+                return $"{searchDepth}{previousLevelDirectory}'";
 
-            return $"(System.FileName LIKE '{itemName}%' " +
-                    $"OR CONTAINS(System.FileName,'\"{itemName}*\"',1033)) AND " +
-                    searchDepth + $"{previousLevelDirectory}'";
+            return $"(System.FileName LIKE '{itemName}%' OR CONTAINS(System.FileName,'\"{itemName}*\"',1033)) AND {searchDepth}{previousLevelDirectory}'";
         }
 
         ///<summary>
@@ -96,9 +94,9 @@ namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
             string query = "SELECT TOP " + settings.MaxResult + $" {CreateBaseQuery().QuerySelectColumns} FROM {SystemIndex} WHERE ";
 
             if (path.LastIndexOf(Constants.AllFilesFolderSearchWildcard) > path.LastIndexOf(Constants.DirectorySeperator))
-                return query + QueryWhereRestrictionsForTopLevelDirectoryAllFilesAndFoldersSearch(path);
+                return query + QueryWhereRestrictionsForTopLevelDirectoryAllFilesAndFoldersSearch(path) + QueryOrderByFileNameRestriction;
 
-            return query + QueryWhereRestrictionsForTopLevelDirectorySearch(path);
+            return query + QueryWhereRestrictionsForTopLevelDirectorySearch(path) + QueryOrderByFileNameRestriction;
         }
 
         ///<summary>
@@ -107,16 +105,17 @@ namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
         public string QueryForAllFilesAndFolders(string userSearchString)
         {
             // Generate SQL from constructed parameters, converting the userSearchString from AQS->WHERE clause
-            return CreateBaseQuery().GenerateSQLFromUserQuery(userSearchString) + " AND " + QueryWhereRestrictionsForAllFilesAndFoldersSearch();
+            return CreateBaseQuery().GenerateSQLFromUserQuery(userSearchString) + " AND " + QueryWhereRestrictionsForAllFilesAndFoldersSearch
+                + QueryOrderByFileNameRestriction;
         }
 
         ///<summary>
         /// Set the required WHERE clause restriction to search for all files and folders.
         ///</summary>
-        public string QueryWhereRestrictionsForAllFilesAndFoldersSearch()
-        {
-            return $"scope='file:'";
-        }
+        public const string QueryWhereRestrictionsForAllFilesAndFoldersSearch = "scope='file:'";
+
+        public const string QueryOrderByFileNameRestriction = " ORDER BY System.FileName";
+
 
         ///<summary>
         /// Search will be performed on all indexed file contents for the specified search keywords.
@@ -125,7 +124,8 @@ namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
         {
             string query = "SELECT TOP " + settings.MaxResult + $" {CreateBaseQuery().QuerySelectColumns} FROM {SystemIndex} WHERE ";
 
-            return query + QueryWhereRestrictionsForFileContentSearch(userSearchString) + " AND " + QueryWhereRestrictionsForAllFilesAndFoldersSearch();
+            return query + QueryWhereRestrictionsForFileContentSearch(userSearchString) + " AND " + QueryWhereRestrictionsForAllFilesAndFoldersSearch
+                + QueryOrderByFileNameRestriction;
         }
 
         ///<summary>

Plugins/Flow.Launcher.Plugin.Explorer/Settings.cs

@@ -1,7 +1,6 @@
 using Flow.Launcher.Plugin.Explorer.Search;
-using Flow.Launcher.Plugin.Explorer.Search.FolderLinks;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
 using System.Collections.Generic;
-using System.Text.Json.Serialization;
 
 namespace Flow.Launcher.Plugin.Explorer
 {
@@ -9,11 +8,14 @@ namespace Flow.Launcher.Plugin.Explorer
     {
         public int MaxResult { get; set; } = 100;
 
-        public List<FolderLink> QuickFolderAccessLinks { get; set; } = new List<FolderLink>();
+        public List<AccessLink> QuickAccessLinks { get; set; } = new List<AccessLink>();
+
+        // as at v1.7.0 this is to maintain backwards compatibility, need to be removed afterwards.
+        public List<AccessLink> QuickFolderAccessLinks { get; set; } = new List<AccessLink>();
 
         public bool UseWindowsIndexForDirectorySearch { get; set; } = true;
 
-        public List<FolderLink> IndexSearchExcludedSubdirectoryPaths { get; set; } = new List<FolderLink>();
+        public List<AccessLink> IndexSearchExcludedSubdirectoryPaths { get; set; } = new List<AccessLink>();
 
         public string SearchActionKeyword { get; set; } = Query.GlobalPluginWildcardSign;
 

Plugins/Flow.Launcher.Plugin.Explorer/ViewModels/SettingsViewModel.cs

@@ -1,8 +1,9 @@
 using Flow.Launcher.Core.Plugin;
 using Flow.Launcher.Infrastructure.Storage;
 using Flow.Launcher.Plugin.Explorer.Search;
-using Flow.Launcher.Plugin.Explorer.Search.FolderLinks;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
 using System.Diagnostics;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Plugin.Explorer.ViewModels
 {
@@ -21,14 +22,19 @@ namespace Flow.Launcher.Plugin.Explorer.ViewModels
             Settings = storage.Load();
         }
 
+        public Task LoadStorage()
+        {
+            return Task.Run(() => Settings = storage.Load());
+        }
+
         public void Save()
         {
             storage.Save();
         }
 
-        internal void RemoveFolderLinkFromQuickFolders(FolderLink selectedRow) => Settings.QuickFolderAccessLinks.Remove(selectedRow);
+        internal void RemoveLinkFromQuickAccess(AccessLink selectedRow) => Settings.QuickAccessLinks.Remove(selectedRow);
 
-        internal void RemoveFolderLinkFromExcludedIndexPaths(FolderLink selectedRow) => Settings.IndexSearchExcludedSubdirectoryPaths.Remove(selectedRow);
+        internal void RemoveAccessLinkFromExcludedIndexPaths(AccessLink selectedRow) => Settings.IndexSearchExcludedSubdirectoryPaths.Remove(selectedRow);
 
         internal void OpenWindowsIndexingOptions()
         {

Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml

@@ -7,7 +7,7 @@
              mc:Ignorable="d" 
              d:DesignHeight="450" d:DesignWidth="800">
     <UserControl.Resources>
-        <DataTemplate x:Key="ListViewTemplateFolderLinks">
+        <DataTemplate x:Key="ListViewTemplateAccessLinks">
             <TextBlock
                 Text="{Binding Nickname, Mode=OneTime}"
                 Margin="0,5,0,5" />
@@ -40,22 +40,22 @@
                     <ListView x:Name="lbxActionKeywords"
                         ItemTemplate="{StaticResource ListViewActionKeywords}"/>
                 </Expander>
-                <Expander Name="expFolderLinks" Header="{DynamicResource plugin_explorer_quickfolderaccess_header}"
-                          Expanded="expFolderLinks_Click" Collapsed="expFolderLinks_Collapsed"
+                <Expander Name="expAccessLinks" Header="{DynamicResource plugin_explorer_quickaccesslinks_header}"
+                          Expanded="expAccessLinks_Click" Collapsed="expAccessLinks_Collapsed"
                           Margin="0 10 0 0">
                     <ListView
-                        x:Name="lbxFolderLinks" AllowDrop="True"
-                        Drop="lbxFolders_Drop"
-                        DragEnter="lbxFolders_DragEnter"
-                        ItemTemplate="{StaticResource ListViewTemplateFolderLinks}"/>
+                        x:Name="lbxAccessLinks" AllowDrop="True"
+                        Drop="lbxAccessLinks_Drop"
+                        DragEnter="lbxAccessLinks_DragEnter"
+                        ItemTemplate="{StaticResource ListViewTemplateAccessLinks}"/>
                 </Expander>
                 <Expander x:Name="expExcludedPaths" Header="{DynamicResource plugin_explorer_indexsearchexcludedpaths_header}" 
                           Expanded="expExcludedPaths_Click"
                           Margin="0 10 0 0">
                     <ListView
                         x:Name="lbxExcludedPaths" AllowDrop="True"
-                        Drop="lbxFolders_Drop"
-                        DragEnter="lbxFolders_DragEnter"
+                        Drop="lbxAccessLinks_Drop"
+                        DragEnter="lbxAccessLinks_DragEnter"
                         ItemTemplate="{StaticResource ListViewTemplateExcludedPaths}"/>
                 </Expander>
             </StackPanel>

Plugins/Flow.Launcher.Plugin.Explorer/Views/ExplorerSettings.xaml.cs

@@ -1,4 +1,4 @@
-using Flow.Launcher.Plugin.Explorer.Search.FolderLinks;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
 using Flow.Launcher.Plugin.Explorer.ViewModels;
 using System;
 using System.Collections.Generic;
@@ -29,7 +29,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
 
             this.viewModel = viewModel;
 
-            lbxFolderLinks.ItemsSource = this.viewModel.Settings.QuickFolderAccessLinks;
+            lbxAccessLinks.ItemsSource = this.viewModel.Settings.QuickAccessLinks;
 
             lbxExcludedPaths.ItemsSource = this.viewModel.Settings.IndexSearchExcludedSubdirectoryPaths;
 
@@ -54,7 +54,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
 
         public void RefreshView()
         {
-            lbxFolderLinks.Items.SortDescriptions.Add(new SortDescription("Path", ListSortDirection.Ascending));
+            lbxAccessLinks.Items.SortDescriptions.Add(new SortDescription("Path", ListSortDirection.Ascending));
 
             lbxExcludedPaths.Items.SortDescriptions.Add(new SortDescription("Path", ListSortDirection.Ascending));
 
@@ -62,7 +62,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
             btnEdit.Visibility = Visibility.Hidden;
             btnAdd.Visibility = Visibility.Hidden;
 
-            if (expFolderLinks.IsExpanded || expExcludedPaths.IsExpanded || expActionKeywords.IsExpanded)
+            if (expAccessLinks.IsExpanded || expExcludedPaths.IsExpanded || expActionKeywords.IsExpanded)
             {
                 if (!expActionKeywords.IsExpanded)
                     btnAdd.Visibility = Visibility.Visible;
@@ -71,7 +71,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
                     && btnEdit.Visibility == Visibility.Hidden)
                     btnEdit.Visibility = Visibility.Visible;
 
-                if ((lbxFolderLinks.Items.Count == 0 && lbxExcludedPaths.Items.Count == 0)
+                if ((lbxAccessLinks.Items.Count == 0 && lbxExcludedPaths.Items.Count == 0)
                     && btnDelete.Visibility == Visibility.Visible
                     && btnEdit.Visibility == Visibility.Visible)
                 {
@@ -79,8 +79,8 @@ namespace Flow.Launcher.Plugin.Explorer.Views
                     btnEdit.Visibility = Visibility.Hidden;
                 }
 
-                if (expFolderLinks.IsExpanded
-                    && lbxFolderLinks.Items.Count > 0
+                if (expAccessLinks.IsExpanded
+                    && lbxAccessLinks.Items.Count > 0
                     && btnDelete.Visibility == Visibility.Hidden
                     && btnEdit.Visibility == Visibility.Hidden)
                 {
@@ -98,7 +98,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
                 }
             }
 
-            lbxFolderLinks.Items.Refresh();
+            lbxAccessLinks.Items.Refresh();
 
             lbxExcludedPaths.Items.Refresh();
 
@@ -113,8 +113,8 @@ namespace Flow.Launcher.Plugin.Explorer.Views
             if (expExcludedPaths.IsExpanded)
                 expExcludedPaths.IsExpanded = false;
 
-            if (expFolderLinks.IsExpanded)
-                expFolderLinks.IsExpanded = false;
+            if (expAccessLinks.IsExpanded)
+                expAccessLinks.IsExpanded = false;
 
             RefreshView();
         }
@@ -125,10 +125,10 @@ namespace Flow.Launcher.Plugin.Explorer.Views
                 expActionKeywords.Height = Double.NaN;
         }
 
-        private void expFolderLinks_Click(object sender, RoutedEventArgs e)
+        private void expAccessLinks_Click(object sender, RoutedEventArgs e)
         {
-            if (expFolderLinks.IsExpanded)
-                expFolderLinks.Height = 215;
+            if (expAccessLinks.IsExpanded)
+                expAccessLinks.Height = 215;
 
             if (expExcludedPaths.IsExpanded)
                 expExcludedPaths.IsExpanded = false;
@@ -139,19 +139,19 @@ namespace Flow.Launcher.Plugin.Explorer.Views
             RefreshView();
         }
 
-        private void expFolderLinks_Collapsed(object sender, RoutedEventArgs e)
+        private void expAccessLinks_Collapsed(object sender, RoutedEventArgs e)
         {
-            if (!expFolderLinks.IsExpanded)
-                expFolderLinks.Height = Double.NaN;
+            if (!expAccessLinks.IsExpanded)
+                expAccessLinks.Height = Double.NaN;
         }
 
         private void expExcludedPaths_Click(object sender, RoutedEventArgs e)
         {
             if (expExcludedPaths.IsExpanded)
-                expFolderLinks.Height = Double.NaN;
+                expAccessLinks.Height = Double.NaN;
 
-            if (expFolderLinks.IsExpanded)
-                expFolderLinks.IsExpanded = false;
+            if (expAccessLinks.IsExpanded)
+                expAccessLinks.IsExpanded = false;
 
             if (expActionKeywords.IsExpanded)
                 expActionKeywords.IsExpanded = false;
@@ -161,7 +161,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
 
         private void btnDelete_Click(object sender, RoutedEventArgs e)
         {
-            var selectedRow = lbxFolderLinks.SelectedItem as FolderLink?? lbxExcludedPaths.SelectedItem as FolderLink;
+            var selectedRow = lbxAccessLinks.SelectedItem as AccessLink?? lbxExcludedPaths.SelectedItem as AccessLink;
 
             if (selectedRow != null)
             {
@@ -169,11 +169,11 @@ namespace Flow.Launcher.Plugin.Explorer.Views
 
                 if (MessageBox.Show(msg, string.Empty, MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                 {
-                    if (expFolderLinks.IsExpanded)
-                        viewModel.RemoveFolderLinkFromQuickFolders(selectedRow);
+                    if (expAccessLinks.IsExpanded)
+                        viewModel.RemoveLinkFromQuickAccess(selectedRow);
 
                     if (expExcludedPaths.IsExpanded)
-                        viewModel.RemoveFolderLinkFromExcludedIndexPaths(selectedRow);
+                        viewModel.RemoveAccessLinkFromExcludedIndexPaths(selectedRow);
 
                     RefreshView();
                 }
@@ -199,7 +199,7 @@ namespace Flow.Launcher.Plugin.Explorer.Views
             }
             else
             {
-                var selectedRow = lbxFolderLinks.SelectedItem as FolderLink ?? lbxExcludedPaths.SelectedItem as FolderLink;
+                var selectedRow = lbxAccessLinks.SelectedItem as AccessLink ?? lbxExcludedPaths.SelectedItem as AccessLink;
 
                 if (selectedRow != null)
                 {
@@ -207,9 +207,9 @@ namespace Flow.Launcher.Plugin.Explorer.Views
                     folderBrowserDialog.SelectedPath = selectedRow.Path;
                     if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
                     {
-                        if (expFolderLinks.IsExpanded)
+                        if (expAccessLinks.IsExpanded)
                         {
-                            var link = viewModel.Settings.QuickFolderAccessLinks.First(x => x.Path == selectedRow.Path);
+                            var link = viewModel.Settings.QuickAccessLinks.First(x => x.Path == selectedRow.Path);
                             link.Path = folderBrowserDialog.SelectedPath;
                         }
 
@@ -235,36 +235,36 @@ namespace Flow.Launcher.Plugin.Explorer.Views
             var folderBrowserDialog = new FolderBrowserDialog();
             if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
             {
-                var newFolderLink = new FolderLink
+                var newAccessLink = new AccessLink
                 {
                     Path = folderBrowserDialog.SelectedPath
                 };
 
-                AddFolderLink(newFolderLink);
+                AddAccessLink(newAccessLink);
             }
 
             RefreshView();
         }
 
-        private void lbxFolders_Drop(object sender, DragEventArgs e)
+        private void lbxAccessLinks_Drop(object sender, DragEventArgs e)
         {
             string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
 
             if (files != null && files.Count() > 0)
             {
-                if (expFolderLinks.IsExpanded && viewModel.Settings.QuickFolderAccessLinks == null)
-                    viewModel.Settings.QuickFolderAccessLinks = new List<FolderLink>();
+                if (expAccessLinks.IsExpanded && viewModel.Settings.QuickAccessLinks == null)
+                    viewModel.Settings.QuickAccessLinks = new List<AccessLink>();
 
                 foreach (string s in files)
                 {
                     if (Directory.Exists(s))
                     {
-                        var newFolderLink = new FolderLink
+                        var newFolderLink = new AccessLink
                         {
                             Path = s
                         };
 
-                        AddFolderLink(newFolderLink);
+                        AddAccessLink(newFolderLink);
                     }
 
                     RefreshView();
@@ -272,28 +272,28 @@ namespace Flow.Launcher.Plugin.Explorer.Views
             }
         }
 
-        private void AddFolderLink(FolderLink newFolderLink)
+        private void AddAccessLink(AccessLink newAccessLink)
         {
-            if (expFolderLinks.IsExpanded
-                    && !viewModel.Settings.QuickFolderAccessLinks.Any(x => x.Path == newFolderLink.Path))
+            if (expAccessLinks.IsExpanded
+                    && !viewModel.Settings.QuickAccessLinks.Any(x => x.Path == newAccessLink.Path))
             {
-                if (viewModel.Settings.QuickFolderAccessLinks == null)
-                    viewModel.Settings.QuickFolderAccessLinks = new List<FolderLink>();
+                if (viewModel.Settings.QuickAccessLinks == null)
+                    viewModel.Settings.QuickAccessLinks = new List<AccessLink>();
 
-                viewModel.Settings.QuickFolderAccessLinks.Add(newFolderLink);
+                viewModel.Settings.QuickAccessLinks.Add(newAccessLink);
             }
 
             if (expExcludedPaths.IsExpanded
-                && !viewModel.Settings.IndexSearchExcludedSubdirectoryPaths.Any(x => x.Path == newFolderLink.Path))
+                && !viewModel.Settings.IndexSearchExcludedSubdirectoryPaths.Any(x => x.Path == newAccessLink.Path))
             {
                 if (viewModel.Settings.IndexSearchExcludedSubdirectoryPaths == null)
-                    viewModel.Settings.IndexSearchExcludedSubdirectoryPaths = new List<FolderLink>();
+                    viewModel.Settings.IndexSearchExcludedSubdirectoryPaths = new List<AccessLink>();
 
-                viewModel.Settings.IndexSearchExcludedSubdirectoryPaths.Add(newFolderLink);
+                viewModel.Settings.IndexSearchExcludedSubdirectoryPaths.Add(newAccessLink);
             }
         }
 
-        private void lbxFolders_DragEnter(object sender, DragEventArgs e)
+        private void lbxAccessLinks_DragEnter(object sender, DragEventArgs e)
         {
             if (e.Data.GetDataPresent(DataFormats.FileDrop))
             {

Plugins/Flow.Launcher.Plugin.Explorer/plugin.json

@@ -7,7 +7,7 @@
   "Name": "Explorer",
   "Description": "Search and manage files and folders. Explorer utilises Windows Index Search",
   "Author": "Jeremy Wu",
-  "Version": "1.2.6",
+  "Version": "1.7.0",
   "Language": "csharp",
   "Website": "https://github.com/Flow-Launcher/Flow.Launcher",
   "ExecuteFileName": "Flow.Launcher.Plugin.Explorer.dll",

Plugins/Flow.Launcher.Plugin.PluginIndicator/Flow.Launcher.Plugin.PluginIndicator.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{FDED22C8-B637-42E8-824A-63B5B6E05A3A}</ProjectGuid>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Flow.Launcher.Plugin.PluginIndicator</RootNamespace>

Plugins/Flow.Launcher.Plugin.PluginsManager/ContextMenu.cs

@@ -25,7 +25,7 @@ namespace Flow.Launcher.Plugin.PluginsManager
                 {
                     Title = Context.API.GetTranslation("plugin_pluginsmanager_plugin_contextmenu_openwebsite_title"),
                     SubTitle = Context.API.GetTranslation("plugin_pluginsmanager_plugin_contextmenu_openwebsite_subtitle"),
-                    IcoPath = "Images\\website.png",
+                    IcoPath = selectedResult.IcoPath,
                     Action = _ => 
                     {
                         SharedCommands.SearchWeb.NewTabInBrowser(pluginManifestInfo.Website);
@@ -63,7 +63,7 @@ namespace Flow.Launcher.Plugin.PluginsManager
                 {
                     Title = Context.API.GetTranslation("plugin_pluginsmanager_plugin_contextmenu_pluginsmanifest_title"),
                     SubTitle = Context.API.GetTranslation("plugin_pluginsmanager_plugin_contextmenu_pluginsmanifest_subtitle"),
-                    IcoPath = selectedResult.IcoPath,
+                    IcoPath = "Images\\manifestsite.png",
                     Action = _ =>
                     {
                         SharedCommands.SearchWeb.NewTabInBrowser("https://github.com/Flow-Launcher/Flow.Launcher.PluginsManifest");

Plugins/Flow.Launcher.Plugin.PluginsManager/Flow.Launcher.Plugin.PluginsManager.csproj

@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
-
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <UseWPF>true</UseWPF>
     <UseWindowsForms>true</UseWindowsForms>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>

Plugins/Flow.Launcher.Plugin.PluginsManager/Languages/sk.xaml

@@ -0,0 +1,39 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    xmlns:system="clr-namespace:System;assembly=mscorlib">
+
+    <!--Dialogues-->
+    <system:String x:Key="plugin_pluginsmanager_downloading_plugin">Sťahovanie pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_please_wait">Čakajte, prosím…</system:String>
+    <system:String x:Key="plugin_pluginsmanager_download_success">Úspešne stiahnuté</system:String>
+    <system:String x:Key="plugin_pluginsmanager_uninstall_prompt">{0} od {1} {2}{3}Chcete odinštalovať tento plugin? Po odinštalovaní sa Flow automaticky reštartuje.</system:String>
+    <system:String x:Key="plugin_pluginsmanager_install_prompt">{0} by {1} {2}{3}Chcete nainštalovať tento plugin? Po nainštalovaní sa Flow automaticky reštartuje.</system:String>
+    <system:String x:Key="plugin_pluginsmanager_install_title">Inštalovať plugin</system:String>
+    <system:String x:Key="plugin_pluginsmanager_uninstall_title">Odinštalovať plugin</system:String>
+    <system:String x:Key="plugin_pluginsmanager_install_errormetadatafile">Inštalácia zlyhala: nepodarilo sa nájsť metadáta súboru plugin.json nového pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_install_error_title">Chyba inštalácie pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_install_error_subtitle">Nastala chyba počas inštaláciu pluginu {0}</system:String>
+    <system:String x:Key="plugin_pluginsmanager_update_noresult_title">Nie je k dispozícii žiadna aktualizácia</system:String>
+    <system:String x:Key="plugin_pluginsmanager_update_noresult_subtitle">Všetky pluginy sú aktuálne</system:String>
+    <system:String x:Key="plugin_pluginsmanager_update_prompt">{0} od {1} {2}{3}Chcete aktualizovať tento plugin? Po odinštalovaní sa Flow automaticky reštartuje.</system:String>
+    <system:String x:Key="plugin_pluginsmanager_update_title">Aktualizácia pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_update_exists">Tento plugin má dostupnú aktualizáciu, chcete ju zobraziť?</system:String>
+    <system:String x:Key="plugin_pluginsmanager_update_alreadyexists">Tento plugin je už nainštalovaný</system:String>
+    
+    <!--Controls-->
+    
+    <!--Plugin Infos-->
+    <system:String x:Key="plugin_pluginsmanager_plugin_name">Správca pluginov</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_description">Správa inštalácie, odinštalácie alebo aktualizácie pluginov programu Flow Launcher</system:String>
+
+    <!--Context menu items-->
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_openwebsite_title">Prejsť na webovú stránku</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_openwebsite_subtitle">Prejsť na webovú stránku pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_gotosourcecode_title">Zobraziť zdrojový kód</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_gotosourcecode_subtitle">Zobraziť zdrojový kód pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_newissue_title">Navrhnúť vylepšenie alebo nahlásiť chybu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_newissue_subtitle">Navrhnúť vylepšenie alebo nahlásiť chybu vývojárovi pluginu</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_pluginsmanifest_title">Prejsť na repozitár pluginov spúšťača Flow</system:String>
+    <system:String x:Key="plugin_pluginsmanager_plugin_contextmenu_pluginsmanifest_subtitle">Prejsť na repozitár pluginov spúšťača Flow a zobraziť príspevky komunity</system:String>
+    
+</ResourceDictionary>

Plugins/Flow.Launcher.Plugin.PluginsManager/Main.cs

@@ -7,10 +7,11 @@ using System.Windows.Controls;
 using Flow.Launcher.Infrastructure;
 using System;
 using System.Threading.Tasks;
+using System.Threading;
 
 namespace Flow.Launcher.Plugin.PluginsManager
 {
-    public class Main : ISettingProvider, IPlugin, ISavable, IContextMenu, IPluginI18n, IReloadable
+    public class Main : ISettingProvider, IAsyncPlugin, ISavable, IContextMenu, IPluginI18n, IAsyncReloadable
     {
         internal PluginInitContext Context { get; set; }
 
@@ -29,14 +30,29 @@ namespace Flow.Launcher.Plugin.PluginsManager
             return new PluginsManagerSettings(viewModel);
         }
 
-        public void Init(PluginInitContext context)
+        public Task InitAsync(PluginInitContext context)
         {
             Context = context;
             viewModel = new SettingsViewModel(context);
             Settings = viewModel.Settings;
             contextMenu = new ContextMenu(Context);
             pluginManager = new PluginsManager(Context, Settings);
-            lastUpdateTime = DateTime.Now;
+            var updateManifestTask = pluginManager.UpdateManifest();
+            _ = updateManifestTask.ContinueWith(t =>
+            {
+                if (t.IsCompletedSuccessfully)
+                {
+                    lastUpdateTime = DateTime.Now;
+                }
+                else
+                {
+                    context.API.ShowMsg("Plugin Manifest Download Fail.",
+                    "Please check if you can connect to github.com. " +
+                    "This error means you may not be able to Install and Update Plugin.", pluginManager.icoPath, false);
+                }
+            });
+
+            return Task.CompletedTask;
         }
 
         public List<Result> LoadContextMenus(Result selectedResult)
@@ -44,7 +60,7 @@ namespace Flow.Launcher.Plugin.PluginsManager
             return contextMenu.LoadContextMenus(selectedResult);
         }
 
-        public List<Result> Query(Query query)
+        public async Task<List<Result>> QueryAsync(Query query, CancellationToken token)
         {
             var search = query.Search.ToLower();
 
@@ -53,16 +69,13 @@ namespace Flow.Launcher.Plugin.PluginsManager
 
             if ((DateTime.Now - lastUpdateTime).TotalHours > 12) // 12 hours
             {
-                Task.Run(async () =>
-                {
-                    await pluginManager.UpdateManifest();
-                    lastUpdateTime = DateTime.Now;
-                });
+                await pluginManager.UpdateManifest();
+                lastUpdateTime = DateTime.Now;
             }
 
             return search switch
             {
-                var s when s.StartsWith(Settings.HotKeyInstall) => pluginManager.RequestInstallOrUpdate(s),
+                var s when s.StartsWith(Settings.HotKeyInstall) => await pluginManager.RequestInstallOrUpdate(s, token),
                 var s when s.StartsWith(Settings.HotkeyUninstall) => pluginManager.RequestUninstall(s),
                 var s when s.StartsWith(Settings.HotkeyUpdate) => pluginManager.RequestUpdate(s),
                 _ => pluginManager.GetDefaultHotKeys().Where(hotkey =>
@@ -88,10 +101,10 @@ namespace Flow.Launcher.Plugin.PluginsManager
             return Context.API.GetTranslation("plugin_pluginsmanager_plugin_description");
         }
 
-        public void ReloadData()
+        public async Task ReloadDataAsync()
         {
-            Task.Run(() => pluginManager.UpdateManifest()).Wait();
+            await pluginManager.UpdateManifest();
             lastUpdateTime = DateTime.Now;
         }
     }
-}
+}

Plugins/Flow.Launcher.Plugin.PluginsManager/Models/PluginsManifest.cs

@@ -9,12 +9,7 @@ namespace Flow.Launcher.Plugin.PluginsManager.Models
 {
     internal class PluginsManifest
     {
-        internal List<UserPlugin> UserPlugins { get; private set; }
-
-        internal PluginsManifest()
-        {
-            Task.Run(async () => await DownloadManifest()).Wait();
-        }
+        internal List<UserPlugin> UserPlugins { get; private set; } = new List<UserPlugin>();
 
         internal async Task DownloadManifest()
         {

Plugins/Flow.Launcher.Plugin.PluginsManager/PluginsManager.cs

@@ -3,10 +3,12 @@ using Flow.Launcher.Infrastructure.Http;
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin.PluginsManager.Models;
+using Flow.Launcher.Plugin.SharedCommands;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
 
@@ -36,7 +38,7 @@ namespace Flow.Launcher.Plugin.PluginsManager
             }
         }
 
-        private readonly string icoPath = "Images\\pluginsmanager.png";
+        internal readonly string icoPath = "Images\\pluginsmanager.png";
 
         internal PluginsManager(PluginInitContext context, Settings settings)
         {
@@ -64,27 +66,27 @@ namespace Flow.Launcher.Plugin.PluginsManager
                         return false;
                     }
                 },
-                    new Result()
+                new Result()
+                {
+                    Title = Settings.HotkeyUninstall,
+                    IcoPath = icoPath,
+                    Action = _ =>
                     {
-                        Title = Settings.HotkeyUninstall,
-                        IcoPath = icoPath,
-                        Action = _ =>
-                        {
-                            Context.API.ChangeQuery("pm uninstall ");
-                            return false;
-                        }
-                    },
-                    new Result()
-                    {
-                        Title = Settings.HotkeyUpdate,
-                        IcoPath = icoPath,
-                        Action = _ =>
-                        {
-                            Context.API.ChangeQuery("pm update ");
-                            return false;
-                        }
+                        Context.API.ChangeQuery("pm uninstall ");
+                        return false;
                     }
-                };
+                },
+                new Result()
+                {
+                    Title = Settings.HotkeyUpdate,
+                    IcoPath = icoPath,
+                    Action = _ =>
+                    {
+                        Context.API.ChangeQuery("pm update ");
+                        return false;
+                    }
+                }
+            };
         }
 
         internal async Task InstallOrUpdate(UserPlugin plugin)
@@ -137,7 +139,8 @@ namespace Flow.Launcher.Plugin.PluginsManager
             catch (Exception e)
             {
                 Context.API.ShowMsg(Context.API.GetTranslation("plugin_pluginsmanager_install_error_title"),
-                    string.Format(Context.API.GetTranslation("plugin_pluginsmanager_install_error_subtitle"), plugin.Name));
+                    string.Format(Context.API.GetTranslation("plugin_pluginsmanager_install_error_subtitle"),
+                        plugin.Name));
 
                 Log.Exception("PluginsManager", "An error occured while downloading plugin", e, "InstallOrUpdate");
 
@@ -164,7 +167,8 @@ namespace Flow.Launcher.Plugin.PluginsManager
                 from existingPlugin in Context.API.GetAllPlugins()
                 join pluginFromManifest in pluginsManifest.UserPlugins
                     on existingPlugin.Metadata.ID equals pluginFromManifest.ID
-                where existingPlugin.Metadata.Version.CompareTo(pluginFromManifest.Version) < 0 // if current version precedes manifest version
+                where existingPlugin.Metadata.Version.CompareTo(pluginFromManifest.Version) <
+                      0 // if current version precedes manifest version
                 select
                     new
                     {
@@ -214,22 +218,29 @@ namespace Flow.Launcher.Plugin.PluginsManager
 
                                 Task.Run(async delegate
                                 {
-                                    Context.API.ShowMsg(Context.API.GetTranslation("plugin_pluginsmanager_downloading_plugin"),
-                                                        Context.API.GetTranslation("plugin_pluginsmanager_please_wait"));
+                                    Context.API.ShowMsg(
+                                        Context.API.GetTranslation("plugin_pluginsmanager_downloading_plugin"),
+                                        Context.API.GetTranslation("plugin_pluginsmanager_please_wait"));
 
-                                    await Http.DownloadAsync(x.PluginNewUserPlugin.UrlDownload, downloadToFilePath).ConfigureAwait(false);
+                                    await Http.DownloadAsync(x.PluginNewUserPlugin.UrlDownload, downloadToFilePath)
+                                        .ConfigureAwait(false);
 
-                                    Context.API.ShowMsg(Context.API.GetTranslation("plugin_pluginsmanager_downloading_plugin"),
-                                                        Context.API.GetTranslation("plugin_pluginsmanager_download_success"));
+                                    Context.API.ShowMsg(
+                                        Context.API.GetTranslation("plugin_pluginsmanager_downloading_plugin"),
+                                        Context.API.GetTranslation("plugin_pluginsmanager_download_success"));
 
                                     Install(x.PluginNewUserPlugin, downloadToFilePath);
 
                                     Context.API.RestartApp();
                                 }).ContinueWith(t =>
                                 {
-                                    Log.Exception("PluginsManager", $"Update failed for {x.Name}", t.Exception.InnerException, "RequestUpdate");
-                                    Context.API.ShowMsg(Context.API.GetTranslation("plugin_pluginsmanager_install_error_title"),
-                                                        string.Format(Context.API.GetTranslation("plugin_pluginsmanager_install_error_subtitle"), x.Name));
+                                    Log.Exception("PluginsManager", $"Update failed for {x.Name}",
+                                        t.Exception.InnerException, "RequestUpdate");
+                                    Context.API.ShowMsg(
+                                        Context.API.GetTranslation("plugin_pluginsmanager_install_error_title"),
+                                        string.Format(
+                                            Context.API.GetTranslation("plugin_pluginsmanager_install_error_subtitle"),
+                                            x.Name));
                                 }, TaskContinuationOptions.OnlyOnFaulted);
 
                                 return true;
@@ -264,8 +275,21 @@ namespace Flow.Launcher.Plugin.PluginsManager
                 .ToList();
         }
 
-        internal List<Result> RequestInstallOrUpdate(string searchName)
+        private Task _downloadManifestTask = Task.CompletedTask;
+
+        internal async ValueTask<List<Result>> RequestInstallOrUpdate(string searchName, CancellationToken token)
         {
+            if (!pluginsManifest.UserPlugins.Any() &&
+                _downloadManifestTask.Status != TaskStatus.Running)
+            {
+                _downloadManifestTask = pluginsManifest.DownloadManifest();
+            }
+
+            await _downloadManifestTask;
+
+            if (token.IsCancellationRequested)
+                return null;
+
             var searchNameWithoutKeyword = searchName.Replace(Settings.HotKeyInstall, string.Empty).Trim();
 
             var results =
@@ -304,7 +328,9 @@ namespace Flow.Launcher.Plugin.PluginsManager
 
             var zipFilePath = Path.Combine(tempFolderPath, Path.GetFileName(downloadedFilePath));
 
-            File.Move(downloadedFilePath, zipFilePath);
+            File.Copy(downloadedFilePath, zipFilePath);
+
+            File.Delete(downloadedFilePath);
 
             Utilities.UnZip(zipFilePath, tempFolderPluginPath, true);
 
@@ -322,7 +348,9 @@ namespace Flow.Launcher.Plugin.PluginsManager
 
             string newPluginPath = Path.Combine(DataLocation.PluginsDirectory, $"{plugin.Name}-{plugin.Version}");
 
-            Directory.Move(pluginFolderPath, newPluginPath);
+            FilesFolders.CopyAll(pluginFolderPath, newPluginPath);
+
+            Directory.Delete(pluginFolderPath, true);
         }
 
         internal List<Result> RequestUninstall(string search)
@@ -406,4 +434,4 @@ namespace Flow.Launcher.Plugin.PluginsManager
             return new List<Result>();
         }
     }
-}
+}

Plugins/Flow.Launcher.Plugin.PluginsManager/plugin.json

@@ -6,7 +6,7 @@
   "Name": "Plugins Manager",
   "Description": "Management of installing, uninstalling or updating Flow Launcher plugins",
   "Author": "Jeremy Wu",
-  "Version": "1.4.1",
+  "Version": "1.6.3",
   "Language": "csharp",
   "Website": "https://github.com/Flow-Launcher/Flow.Launcher",
   "ExecuteFileName": "Flow.Launcher.Plugin.PluginsManager.dll",

Plugins/Flow.Launcher.Plugin.ProcessKiller/Flow.Launcher.Plugin.ProcessKiller.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <AssemblyName>Flow.Launcher.Plugin.ProcessKiller</AssemblyName>
     <PackageId>Flow.Launcher.Plugin.ProcessKiller</PackageId>
     <Authors>Flow-Launcher</Authors>

Plugins/Flow.Launcher.Plugin.Program/Flow.Launcher.Plugin.Program.csproj

@@ -1,8 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFramework>net5.0-windows10.0.19041.0</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
     <ProjectGuid>{FDB3555B-58EF-4AE6-B5F1-904719637AB4}</ProjectGuid>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>Flow.Launcher.Plugin.Program</RootNamespace>
@@ -69,6 +69,7 @@
   </ItemGroup>
   
   <ItemGroup>
+    <PackageReference Include="Microsoft.Windows.SDK.Contracts" Version="10.0.18362.2005" />
     <PackageReference Include="System.Runtime" Version="4.3.1" />
   </ItemGroup>
 

Plugins/Flow.Launcher.Plugin.Program/Main.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Controls;
 using Flow.Launcher.Infrastructure.Logger;
@@ -12,9 +13,8 @@ using Stopwatch = Flow.Launcher.Infrastructure.Stopwatch;
 
 namespace Flow.Launcher.Plugin.Program
 {
-    public class Main : ISettingProvider, IPlugin, IPluginI18n, IContextMenu, ISavable, IReloadable
+    public class Main : ISettingProvider, IAsyncPlugin, IPluginI18n, IContextMenu, ISavable, IAsyncReloadable
     {
-        private static readonly object IndexLock = new object();
         internal static Win32[] _win32s { get; set; }
         internal static UWP.Application[] _uwps { get; set; }
         internal static Settings _settings { get; set; }
@@ -30,33 +30,6 @@ namespace Flow.Launcher.Plugin.Program
         public Main()
         {
             _settingsStorage = new PluginJsonStorage<Settings>();
-            _settings = _settingsStorage.Load();
-
-            Stopwatch.Normal("|Flow.Launcher.Plugin.Program.Main|Preload programs cost", () =>
-            {
-                _win32Storage = new BinaryStorage<Win32[]>("Win32");
-                _win32s = _win32Storage.TryLoad(new Win32[] { });
-                _uwpStorage = new BinaryStorage<UWP.Application[]>("UWP");
-                _uwps = _uwpStorage.TryLoad(new UWP.Application[] { });
-            });
-            Log.Info($"|Flow.Launcher.Plugin.Program.Main|Number of preload win32 programs <{_win32s.Length}>");
-            Log.Info($"|Flow.Launcher.Plugin.Program.Main|Number of preload uwps <{_uwps.Length}>");
-
-            var a = Task.Run(() =>
-            {
-                if (IsStartupIndexProgramsRequired || !_win32s.Any())
-                    Stopwatch.Normal("|Flow.Launcher.Plugin.Program.Main|Win32Program index cost", IndexWin32Programs);
-            });
-
-            var b = Task.Run(() =>
-            {
-                if (IsStartupIndexProgramsRequired || !_uwps.Any())
-                    Stopwatch.Normal("|Flow.Launcher.Plugin.Program.Main|Win32Program index cost", IndexUWPPrograms);
-            });
-
-            Task.WaitAll(a, b);
-
-            _settings.LastIndexTime = DateTime.Today;
         }
 
         public void Save()
@@ -66,28 +39,92 @@ namespace Flow.Launcher.Plugin.Program
             _uwpStorage.Save(_uwps);
         }
 
-        public List<Result> Query(Query query)
+        public async Task<List<Result>> QueryAsync(Query query, CancellationToken token)
         {
+            if (IsStartupIndexProgramsRequired)
+                _ = IndexPrograms();
+
             Win32[] win32;
             UWP.Application[] uwps;
 
             win32 = _win32s;
             uwps = _uwps;
 
-            var result = win32.Cast<IProgram>()
-                 .Concat(uwps)
-                 .AsParallel()
-                 .Where(p => p.Enabled)
-                 .Select(p => p.Result(query.Search, _context.API))
-                 .Where(r => r?.Score > 0)
-                 .ToList();
+            try
+            {
+                var result = await Task.Run(delegate
+                {
+                    try
+                    {
+                        return win32.Cast<IProgram>()
+                            .Concat(uwps)
+                            .AsParallel()
+                            .WithCancellation(token)
+                            .Where(p => p.Enabled)
+                            .Select(p => p.Result(query.Search, _context.API))
+                            .Where(r => r?.Score > 0)
+                            .ToList();
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        return null;
+                    }
+                }, token).ConfigureAwait(false);
 
-            return result;
+                token.ThrowIfCancellationRequested();
+
+                return result;
+            }
+            catch (OperationCanceledException)
+            {
+                return null;
+            }
         }
 
-        public void Init(PluginInitContext context)
+        public async Task InitAsync(PluginInitContext context)
         {
             _context = context;
+
+            await Task.Run(() =>
+            {
+                _settings = _settingsStorage.Load();
+
+                Stopwatch.Normal("|Flow.Launcher.Plugin.Program.Main|Preload programs cost", () =>
+                {
+                    _win32Storage = new BinaryStorage<Win32[]>("Win32");
+                    _win32s = _win32Storage.TryLoad(new Win32[] { });
+                    _uwpStorage = new BinaryStorage<UWP.Application[]>("UWP");
+                    _uwps = _uwpStorage.TryLoad(new UWP.Application[] { });
+                });
+                Log.Info($"|Flow.Launcher.Plugin.Program.Main|Number of preload win32 programs <{_win32s.Length}>");
+                Log.Info($"|Flow.Launcher.Plugin.Program.Main|Number of preload uwps <{_uwps.Length}>");
+            });
+
+            bool indexedWinApps = false;
+            bool indexedUWPApps = false;
+
+            var a = Task.Run(() =>
+            {
+                if (IsStartupIndexProgramsRequired || !_win32s.Any())
+                {
+                    Stopwatch.Normal("|Flow.Launcher.Plugin.Program.Main|Win32Program index cost", IndexWin32Programs);
+                    indexedWinApps = true;
+                }
+            });
+
+            var b = Task.Run(() =>
+            {
+                if (IsStartupIndexProgramsRequired || !_uwps.Any())
+                {
+                    Stopwatch.Normal("|Flow.Launcher.Plugin.Program.Main|Win32Program index cost", IndexUwpPrograms);
+                    indexedUWPApps = true;
+                }
+            });
+
+            await Task.WhenAll(a, b);
+
+            if (indexedWinApps && indexedUWPApps)
+                _settings.LastIndexTime = DateTime.Today;
         }
 
         public static void IndexWin32Programs()
@@ -95,10 +132,9 @@ namespace Flow.Launcher.Plugin.Program
             var win32S = Win32.All(_settings);
 
             _win32s = win32S;
-
         }
 
-        public static void IndexUWPPrograms()
+        public static void IndexUwpPrograms()
         {
             var windows10 = new Version(10, 0);
             var support = Environment.OSVersion.Version.Major >= windows10.Major;
@@ -106,16 +142,15 @@ namespace Flow.Launcher.Plugin.Program
             var applications = support ? UWP.All() : new UWP.Application[] { };
 
             _uwps = applications;
-
         }
 
-        public static void IndexPrograms()
+        public static async Task IndexPrograms()
         {
-            var t1 = Task.Run(() => IndexWin32Programs());
+            var t1 = Task.Run(IndexWin32Programs);
 
-            var t2 = Task.Run(() => IndexUWPPrograms());
+            var t2 = Task.Run(IndexUwpPrograms);
 
-            Task.WaitAll(t1, t2);
+            await Task.WhenAll(t1, t2).ConfigureAwait(false);
 
             _settings.LastIndexTime = DateTime.Today;
         }
@@ -145,19 +180,21 @@ namespace Flow.Launcher.Plugin.Program
             }
 
             menuOptions.Add(
-                                new Result
-                                {
-                                    Title = _context.API.GetTranslation("flowlauncher_plugin_program_disable_program"),
-                                    Action = c =>
-                                    {
-                                        DisableProgram(program);
-                                        _context.API.ShowMsg(_context.API.GetTranslation("flowlauncher_plugin_program_disable_dlgtitle_success"),
-                                                                _context.API.GetTranslation("flowlauncher_plugin_program_disable_dlgtitle_success_message"));
-                                        return false;
-                                    },
-                                    IcoPath = "Images/disable.png"
-                                }
-                           );
+                new Result
+                {
+                    Title = _context.API.GetTranslation("flowlauncher_plugin_program_disable_program"),
+                    Action = c =>
+                    {
+                        DisableProgram(program);
+                        _context.API.ShowMsg(
+                            _context.API.GetTranslation("flowlauncher_plugin_program_disable_dlgtitle_success"),
+                            _context.API.GetTranslation(
+                                "flowlauncher_plugin_program_disable_dlgtitle_success_message"));
+                        return false;
+                    },
+                    IcoPath = "Images/disable.png"
+                }
+            );
 
             return menuOptions;
         }
@@ -168,21 +205,25 @@ namespace Flow.Launcher.Plugin.Program
                 return;
 
             if (_uwps.Any(x => x.UniqueIdentifier == programToDelete.UniqueIdentifier))
-                _uwps.Where(x => x.UniqueIdentifier == programToDelete.UniqueIdentifier).FirstOrDefault().Enabled = false;
+                _uwps.Where(x => x.UniqueIdentifier == programToDelete.UniqueIdentifier)
+                    .FirstOrDefault()
+                    .Enabled = false;
 
             if (_win32s.Any(x => x.UniqueIdentifier == programToDelete.UniqueIdentifier))
-                _win32s.Where(x => x.UniqueIdentifier == programToDelete.UniqueIdentifier).FirstOrDefault().Enabled = false;
+                _win32s.Where(x => x.UniqueIdentifier == programToDelete.UniqueIdentifier)
+                    .FirstOrDefault()
+                    .Enabled = false;
 
             _settings.DisabledProgramSources
-                     .Add(
-                             new Settings.DisabledProgramSource
-                             {
-                                 Name = programToDelete.Name,
-                                 Location = programToDelete.Location,
-                                 UniqueIdentifier = programToDelete.UniqueIdentifier,
-                                 Enabled = false
-                             }
-                         );
+                .Add(
+                    new Settings.DisabledProgramSource
+                    {
+                        Name = programToDelete.Name,
+                        Location = programToDelete.Location,
+                        UniqueIdentifier = programToDelete.UniqueIdentifier,
+                        Enabled = false
+                    }
+                );
         }
 
         public static void StartProcess(Func<ProcessStartInfo, Process> runProcess, ProcessStartInfo info)
@@ -200,9 +241,9 @@ namespace Flow.Launcher.Plugin.Program
             }
         }
 
-        public void ReloadData()
+        public async Task ReloadDataAsync()
         {
-            IndexPrograms();
+            await IndexPrograms();
         }
     }
-}
+}