Release 1.8.2

Flow.Launcher.Core/Plugin/JsonRPCPlugin.cs

@@ -40,15 +40,7 @@ internal abstract class JsonRPCPlugin : IAsyncPlugin, IContextMenu
         public List<Result> LoadContextMenus(Result selectedResult)
         {
             var output = ExecuteContextMenu(selectedResult);
-            try
-            {
-                return DeserializedResult(output);
-            }
-            catch (Exception e)
-            {
-                Log.Exception($"|JsonRPCPlugin.LoadContextMenus|Exception on result <{selectedResult}>", e);
-                return null;
-            }
+            return DeserializedResult(output);
         }
 
         private static readonly JsonSerializerOptions options = new()
@@ -65,23 +57,10 @@ private async Task<List<Result>> DeserializedResultAsync(Stream output)
         {
             if (output == Stream.Null) return null;
 
-            try
-            {
-                var queryResponseModel =
-                    await JsonSerializer.DeserializeAsync<JsonRPCQueryResponseModel>(output, options);
-
-                return ParseResults(queryResponseModel);
-            }
-            catch (JsonException e)
-            {
-                Log.Exception(GetType().FullName, "Unexpected Json Input", e);
-            }
-            finally
-            {
-                await output.DisposeAsync();
-            }
+            var queryResponseModel =
+                await JsonSerializer.DeserializeAsync<JsonRPCQueryResponseModel>(output, options);
 
-            return null;
+            return ParseResults(queryResponseModel);
         }
 
         private List<Result> DeserializedResult(string output)
@@ -249,7 +228,7 @@ protected async Task<Stream> ExecuteAsync(ProcessStartInfo startInfo, Cancellati
                 await using var source = process.StandardOutput.BaseStream;
 
                 var buffer = BufferManager.GetStream();
-                
+
                 token.Register(() =>
                 {
                     // ReSharper disable once AccessToModifiedClosure
@@ -274,30 +253,27 @@ protected async Task<Stream> ExecuteAsync(ProcessStartInfo startInfo, Cancellati
 
                 token.ThrowIfCancellationRequested();
 
+                if (buffer.Length == 0)
+                {
+                    var errorMessage = process.StandardError.EndOfStream ? 
+                        "Empty JSONRPC Response" : 
+                        await process.StandardError.ReadToEndAsync();
+                    throw new InvalidDataException($"{context.CurrentPluginMetadata.Name}|{errorMessage}");
+                }
+
                 if (!process.StandardError.EndOfStream)
                 {
                     using var standardError = process.StandardError;
                     var error = await standardError.ReadToEndAsync();
 
                     if (!string.IsNullOrEmpty(error))
                     {
-                        Log.Error($"|JsonRPCPlugin.ExecuteAsync|{error}");
-                        return Stream.Null;
+                        Log.Error($"|{context.CurrentPluginMetadata.Name}.{nameof(ExecuteAsync)}|{error}");
                     }
-
-                    Log.Error("|JsonRPCPlugin.ExecuteAsync|Empty standard output and standard error.");
-                    return Stream.Null;
                 }
 
                 return buffer;
             }
-            catch (Exception e)
-            {
-                Log.Exception(
-                    $"|JsonRPCPlugin.ExecuteAsync|Exception for filename <{startInfo.FileName}> with argument <{startInfo.Arguments}>",
-                    e);
-                return Stream.Null;
-            }
             finally
             {
                 process?.Dispose();
@@ -307,20 +283,8 @@ protected async Task<Stream> ExecuteAsync(ProcessStartInfo startInfo, Cancellati
 
         public async Task<List<Result>> QueryAsync(Query query, CancellationToken token)
         {
-            try
-            {
-                var output = await ExecuteQueryAsync(query, token);
-                return await DeserializedResultAsync(output);
-            }
-            catch (OperationCanceledException)
-            {
-                return null;
-            }
-            catch (Exception e)
-            {
-                Log.Exception($"|JsonRPCPlugin.Query|Exception when query <{query}>", e);
-                return null;
-            }
+            var output = await ExecuteQueryAsync(query, token);
+            return await DeserializedResultAsync(output);
         }
 
         public virtual Task InitAsync(PluginInitContext context)
@@ -329,4 +293,4 @@ public virtual Task InitAsync(PluginInitContext context)
             return Task.CompletedTask;
         }
     }
-}
+}

Flow.Launcher.Infrastructure/Image/ImageCache.cs

@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Media;
 
@@ -26,7 +27,8 @@ public class ImageCache
         private const int MaxCached = 50;
         public ConcurrentDictionary<string, ImageUsage> Data { get; private set; } = new ConcurrentDictionary<string, ImageUsage>();
         private const int permissibleFactor = 2;
-
+        private SemaphoreSlim semaphore = new(1, 1);
+
         public void Initialization(Dictionary<string, int> usage)
         {
             foreach (var key in usage.Keys)
@@ -60,20 +62,29 @@ public ImageSource this[string path]
                             }
                 );
 
-                // To prevent the dictionary from drastically increasing in size by caching images, the dictionary size is not allowed to grow more than the permissibleFactor * maxCached size
-                // This is done so that we don't constantly perform this resizing operation and also maintain the image cache size at the same time
-                if (Data.Count > permissibleFactor * MaxCached)
+                SliceExtra();
+
+                async void SliceExtra()
                 {
-                    // To delete the images from the data dictionary based on the resizing of the Usage Dictionary.
-                    foreach (var key in Data.OrderBy(x => x.Value.usage).Take(Data.Count - MaxCached).Select(x => x.Key))
-                        Data.TryRemove(key, out _);
+                    // To prevent the dictionary from drastically increasing in size by caching images, the dictionary size is not allowed to grow more than the permissibleFactor * maxCached size
+                    // This is done so that we don't constantly perform this resizing operation and also maintain the image cache size at the same time
+                    if (Data.Count > permissibleFactor * MaxCached)
+                    {
+                        await semaphore.WaitAsync().ConfigureAwait(false);
+                        // To delete the images from the data dictionary based on the resizing of the Usage Dictionary
+                        // Double Check to avoid concurrent remove
+                        if (Data.Count > permissibleFactor * MaxCached)
+                            foreach (var key in Data.OrderBy(x => x.Value.usage).Take(Data.Count - MaxCached).Select(x => x.Key).ToArray())
+                                Data.TryRemove(key, out _);
+                        semaphore.Release();
+                    }
                 }
             }
         }
 
         public bool ContainsKey(string key)
         {
-            return Data.ContainsKey(key) && Data[key].imageSource != null;
+            return key is not null && Data.ContainsKey(key) && Data[key].imageSource != null;
         }
 
         public int CacheSize()

Flow.Launcher.Infrastructure/UserSettings/PluginSettings.cs

@@ -18,7 +18,7 @@ public void UpdatePluginSettings(List<PluginMetadata> metadatas)
 
                     // TODO: Remove. This is backwards compatibility for 1.8.0 release.
                     // Introduced two new action keywords in Explorer, so need to update plugin setting in the UserData folder.
-                    if (metadata.ID == "572be03c74c642baae319fc283e561a8" && metadata.ActionKeywords.Count != settings.ActionKeywords.Count)
+                    if (metadata.ID == "572be03c74c642baae319fc283e561a8" && metadata.ActionKeywords.Count > settings.ActionKeywords.Count)
                     {
                         settings.ActionKeywords.Add(Query.GlobalPluginWildcardSign); // for index search
                         settings.ActionKeywords.Add(Query.GlobalPluginWildcardSign); // for path search

Flow.Launcher.Infrastructure/UserSettings/Settings.cs

@@ -39,7 +39,8 @@ public string Language
         /// </summary>
         public bool ShouldUsePinyin { get; set; } = false;
 
-        internal SearchPrecisionScore QuerySearchPrecision { get; private set; } = SearchPrecisionScore.Regular;
+        [JsonInclude, JsonConverter(typeof(JsonStringEnumConverter))]
+        public SearchPrecisionScore QuerySearchPrecision { get; private set; } = SearchPrecisionScore.Regular;
 
         [JsonIgnore]
         public string QuerySearchPrecisionString

Flow.Launcher/ResultListBox.xaml

@@ -42,7 +42,7 @@
                             <ColumnDefinition Width="0" />
                         </Grid.ColumnDefinitions>
                         <Image x:Name="ImageIcon" Width="32" Height="32" HorizontalAlignment="Left"
-                               Source="{Binding Image.Value}" />
+                               Source="{Binding Image}" />
                         <Grid Margin="5 0 5 0" Grid.Column="1" HorizontalAlignment="Stretch">
                             <Grid.RowDefinitions>
                                 <RowDefinition />

Flow.Launcher/ViewModel/MainViewModel.cs

@@ -108,9 +108,7 @@ async Task updateAction()
                 }
 
                 Log.Error("MainViewModel", "Unexpected ResultViewUpdate ends");
-            }
-
-            ;
+            };
 
             void continueAction(Task t)
             {

Flow.Launcher/ViewModel/ResultViewModel.cs

@@ -11,62 +11,12 @@ namespace Flow.Launcher.ViewModel
 {
     public class ResultViewModel : BaseModel
     {
-        public class LazyAsync<T> : Lazy<ValueTask<T>>
-        {
-            private readonly T defaultValue;
-
-            private readonly Action _updateCallback;
-            public new T Value
-            {
-                get
-                {
-                    if (!IsValueCreated)
-                    {
-                        _ = Exercute(); // manually use callback strategy
-
-                        return defaultValue;
-                    }
-
-                    if (!base.Value.IsCompletedSuccessfully)
-                        return defaultValue;
-
-                    return base.Value.Result;
-
-                    // If none of the variables captured by the local function are captured by other lambdas,
-                    // the compiler can avoid heap allocations.
-                    async ValueTask Exercute()
-                    {
-                        await base.Value.ConfigureAwait(false);
-                        _updateCallback();
-                    }
-
-                }
-            }
-            public LazyAsync(Func<ValueTask<T>> factory, T defaultValue, Action updateCallback) : base(factory)
-            {
-                if (defaultValue != null)
-                {
-                    this.defaultValue = defaultValue;
-                }
-
-                _updateCallback = updateCallback;
-            }
-        }
-
         public ResultViewModel(Result result, Settings settings)
         {
             if (result != null)
             {
                 Result = result;
-
-                Image = new LazyAsync<ImageSource>(
-                            SetImage,
-                            ImageLoader.DefaultImage,
-                            () =>
-                                {
-                                    OnPropertyChanged(nameof(Image));
-                                });
-            } 
+            }
 
             Settings = settings;
         }
@@ -85,44 +35,55 @@ public ResultViewModel(Result result, Settings settings)
                                                 ? Result.SubTitle
                                                 : Result.SubTitleToolTip;
 
-        public LazyAsync<ImageSource> Image { get; set; }
+        private volatile bool ImageLoaded;
+
+        private ImageSource image = ImageLoader.DefaultImage;
 
-        private async ValueTask<ImageSource> SetImage()
+        public ImageSource Image
+        {
+            get
+            {
+                if (!ImageLoaded)
+                {
+                    ImageLoaded = true;
+                    _ = LoadImageAsync();
+                }
+                return image;
+            }
+            private set => image = value;
+        }
+        private async ValueTask LoadImageAsync()
         {
             var imagePath = Result.IcoPath;
             if (string.IsNullOrEmpty(imagePath) && Result.Icon != null)
             {
                 try
                 {
-                    return Result.Icon();
+                    image = Result.Icon();
+                    return;
                 }
                 catch (Exception e)
                 {
                     Log.Exception($"|ResultViewModel.Image|IcoPath is empty and exception when calling Icon() for result <{Result.Title}> of plugin <{Result.PluginDirectory}>", e);
-                    return ImageLoader.DefaultImage;
                 }
             }
 
             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);
+                image = ImageLoader.Load(imagePath);
+                return;
+            }
 
-            return await Task.Run(() => ImageLoader.Load(imagePath));
+            // We need to modify the property not field here to trigger the OnPropertyChanged event
+            Image = await Task.Run(() => ImageLoader.Load(imagePath)).ConfigureAwait(false);
         }
 
         public Result Result { get; }
 
         public override bool Equals(object obj)
         {
-            var r = obj as ResultViewModel;
-            if (r != null)
-            {
-                return Result.Equals(r.Result);
-            }
-            else
-            {
-                return false;
-            }
+            return obj is ResultViewModel r && Result.Equals(r.Result);
         }
 
         public override int GetHashCode()

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

@@ -52,7 +52,7 @@ internal static Result CreateFolderResult(string title, string subtitle, string
                 },
                 Score = score,
                 TitleToolTip = Constants.ToolTipOpenDirectory,
-                SubTitleToolTip = Constants.ToolTipOpenDirectory,
+                SubTitleToolTip = path,
                 ContextData = new SearchResult
                 {
                     Type = ResultType.Folder,
@@ -144,7 +144,7 @@ internal static Result CreateFileResult(string filePath, Query query, int score
                     return true;
                 },
                 TitleToolTip = Constants.ToolTipOpenContainingFolder,
-                SubTitleToolTip = Constants.ToolTipOpenContainingFolder,
+                SubTitleToolTip = filePath,
                 ContextData = new SearchResult
                 {
                     Type = ResultType.File,

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

@@ -143,7 +143,7 @@ private async Task<List<Result>> WindowsIndexFileContentSearchAsync(Query query,
 
             return await IndexSearch.WindowsIndexSearchAsync(
                 querySearchString,
-                queryConstructor.CreateQueryHelper(),
+                queryConstructor.CreateQueryHelper,
                 queryConstructor.QueryForFileContentSearch,
                 Settings.IndexSearchExcludedSubdirectoryPaths,
                 query,
@@ -181,7 +181,7 @@ private async Task<List<Result>> WindowsIndexFilesAndFoldersSearchAsync(Query qu
 
             return await IndexSearch.WindowsIndexSearchAsync(
                 querySearchString,
-                queryConstructor.CreateQueryHelper(),
+                queryConstructor.CreateQueryHelper,
                 queryConstructor.QueryForAllFilesAndFolders,
                 Settings.IndexSearchExcludedSubdirectoryPaths,
                 query,
@@ -195,7 +195,7 @@ private async Task<List<Result>> WindowsIndexTopLevelFolderSearchAsync(Query que
 
             return await IndexSearch.WindowsIndexSearchAsync(
                 path,
-                queryConstructor.CreateQueryHelper(),
+                queryConstructor.CreateQueryHelper,
                 queryConstructor.QueryForTopLevelDirectorySearch,
                 Settings.IndexSearchExcludedSubdirectoryPaths,
                 query,