Merge branch 'dev' into 250331-NewPluginsPage

Author: onesounds

Flow.Launcher.Core/Plugin/JsonRPCV2Models/JsonRPCPublicAPI.cs

@@ -12,7 +12,7 @@ namespace Flow.Launcher.Core.Plugin.JsonRPCV2Models
 {
     public class JsonRPCPublicAPI
     {
-        private IPublicAPI _api;
+        private readonly IPublicAPI _api;
 
         public JsonRPCPublicAPI(IPublicAPI api)
         {
@@ -104,7 +104,6 @@ public List<PluginPair> GetAllPlugins()
             return _api.GetAllPlugins();
         }
 
-
         public MatchResult FuzzySearch(string query, string stringToCompare)
         {
             return _api.FuzzySearch(query, stringToCompare);
@@ -156,6 +155,11 @@ public void LogWarn(string className, string message, [CallerMemberName] string
             _api.LogWarn(className, message, methodName);
         }
 
+        public void LogError(string className, string message, [CallerMemberName] string methodName = "")
+        {
+            _api.LogError(className, message, methodName);
+        }
+
         public void OpenDirectory(string DirectoryPath, string FileNameOrFilePath = null)
         {
             _api.OpenDirectory(DirectoryPath, FileNameOrFilePath);
@@ -185,5 +189,10 @@ public void StopLoadingBar()
         {
             _api.StopLoadingBar();
         }
+
+        public void SavePluginCaches()
+        {
+            _api.SavePluginCaches();
+        }
     }
 }

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -13,6 +13,7 @@
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedCommands;
+using IRemovable = Flow.Launcher.Core.Storage.IRemovable;
 using ISavable = Flow.Launcher.Plugin.ISavable;
 
 namespace Flow.Launcher.Core.Plugin
@@ -65,6 +66,7 @@ public static void Save()
             }
 
             API.SavePluginSettings();
+            API.SavePluginCaches();
         }
 
         public static async ValueTask DisposePluginsAsync()
@@ -575,11 +577,11 @@ internal static async Task UninstallPluginAsync(PluginMetadata plugin, bool remo
 
             if (removePluginSettings)
             {
-                // For dotnet plugins, we need to remove their PluginJsonStorage instance
-                if (AllowedLanguage.IsDotNet(plugin.Language))
+                // For dotnet plugins, we need to remove their PluginJsonStorage and PluginBinaryStorage instances
+                if (AllowedLanguage.IsDotNet(plugin.Language) && API is IRemovable removable)
                 {
-                    var method = API.GetType().GetMethod("RemovePluginSettings");
-                    method?.Invoke(API, new object[] { plugin.AssemblyName });
+                    removable.RemovePluginSettings(plugin.AssemblyName);
+                    removable.RemovePluginCaches(plugin.PluginCacheDirectoryPath);
                 }
 
                 try

Flow.Launcher.Core/Resource/Theme.cs

@@ -16,6 +16,7 @@
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
+using Flow.Launcher.Plugin.SharedModels;
 using Microsoft.Win32;
 
 namespace Flow.Launcher.Core.Resource
@@ -81,11 +82,6 @@ public Theme(IPublicAPI publicAPI, Settings settings)
 
         #region Theme Resources
 
-        public string GetCurrentTheme()
-        {
-            return _settings.Theme;
-        }
-
         private void MakeSureThemeDirectoriesExist()
         {
             foreach (var dir in _themeDirectories.Where(dir => !Directory.Exists(dir)))
@@ -127,7 +123,7 @@ public void UpdateFonts()
             try
             {
                 // Load a ResourceDictionary for the specified theme.
-                var themeName = GetCurrentTheme();
+                var themeName = _settings.Theme;
                 var dict = GetThemeResourceDictionary(themeName);
 
                 // Apply font settings to the theme resource.
@@ -330,7 +326,7 @@ private ResourceDictionary GetResourceDictionary(string theme)
 
         private ResourceDictionary GetCurrentResourceDictionary()
         {
-            return GetResourceDictionary(GetCurrentTheme());
+            return GetResourceDictionary(_settings.Theme);
         }
 
         private ThemeData GetThemeDataFromPath(string path)
@@ -383,9 +379,20 @@ private string GetThemePath(string themeName)
 
         #endregion
 
-        #region Load & Change
+        #region Get & Change Theme
+
+        public ThemeData GetCurrentTheme()
+        {
+            var themes = GetAvailableThemes();
+            var matchingTheme = themes.FirstOrDefault(t => t.FileNameWithoutExtension == _settings.Theme);
+            if (matchingTheme == null)
+            {
+                Log.Warn($"No matching theme found for '{_settings.Theme}'. Falling back to the first available theme.");
+            }
+            return matchingTheme ?? themes.FirstOrDefault();
+        }
 
-        public List<ThemeData> LoadAvailableThemes()
+        public List<ThemeData> GetAvailableThemes()
         {
             List<ThemeData> themes = new List<ThemeData>();
             foreach (var themeDirectory in _themeDirectories)
@@ -403,7 +410,7 @@ public List<ThemeData> LoadAvailableThemes()
         public bool ChangeTheme(string theme = null)
         {
             if (string.IsNullOrEmpty(theme))
-                theme = GetCurrentTheme();
+                theme = _settings.Theme;
 
             string path = GetThemePath(theme);
             try
@@ -426,7 +433,7 @@ public bool ChangeTheme(string theme = null)
 
                 BlurEnabled = IsBlurTheme();
 
-                // Can only apply blur but here also apply drop shadow effect to avoid possible drop shadow effect issues
+                // Apply blur and drop shadow effect so that we do not need to call it again
                 _ = RefreshFrameAsync();
 
                 return true;
@@ -591,7 +598,7 @@ await Application.Current.Dispatcher.InvokeAsync(() =>
                 {
                     AutoDropShadow(useDropShadowEffect);
                 }
-                SetBlurForWindow(GetCurrentTheme(), backdropType);
+                SetBlurForWindow(_settings.Theme, backdropType);
 
                 if (!BlurEnabled)
                 {
@@ -610,7 +617,7 @@ await Application.Current.Dispatcher.InvokeAsync(() =>
                 // Get the actual backdrop type and drop shadow effect settings
                 var (backdropType, _) = GetActualValue();
 
-                SetBlurForWindow(GetCurrentTheme(), backdropType);
+                SetBlurForWindow(_settings.Theme, backdropType);
             }, DispatcherPriority.Render);
         }
 
@@ -898,11 +905,5 @@ private static bool IsBlurTheme()
         }
 
         #endregion
-
-        #region Classes
-
-        public record ThemeData(string FileNameWithoutExtension, string Name, bool? IsDark = null, bool? HasBlur = null);
-
-        #endregion
     }
 }

Flow.Launcher.Core/Storage/IRemovable.cs

@@ -0,0 +1,19 @@
+namespace Flow.Launcher.Core.Storage;
+
+/// <summary>
+/// Remove storage instances from <see cref="Launcher.Plugin.IPublicAPI"/> instance
+/// </summary>
+public interface IRemovable
+{
+    /// <summary>
+    /// Remove all <see cref="Infrastructure.Storage.PluginJsonStorage{T}"/> instances of one plugin
+    /// </summary>
+    /// <param name="assemblyName"></param>
+    public void RemovePluginSettings(string assemblyName);
+
+    /// <summary>
+    /// Remove all <see cref="Infrastructure.Storage.PluginBinaryStorage{T}"/> instances of one plugin
+    /// </summary>
+    /// <param name="cacheDirectory"></param>
+    public void RemovePluginCaches(string cacheDirectory);
+}

Flow.Launcher.Infrastructure/Image/ImageLoader.cs

@@ -34,6 +34,7 @@ public static async Task InitializeAsync()
             _hashGenerator = new ImageHashGenerator();
 
             var usage = await LoadStorageToConcurrentDictionaryAsync();
+            _storage.ClearData();
 
             ImageCache.Initialize(usage);
 
@@ -284,7 +285,7 @@ public static bool TryGetValue(string path, bool loadFullImage, out ImageSource
             return ImageCache.TryGetValue(path, loadFullImage, out image);
         }
 
-        public static async ValueTask<ImageSource> LoadAsync(string path, bool loadFullImage = false)
+        public static async ValueTask<ImageSource> LoadAsync(string path, bool loadFullImage = false, bool cacheImage = true)
         {
             var imageResult = await LoadInternalAsync(path, loadFullImage);
 
@@ -300,16 +301,18 @@ public static async ValueTask<ImageSource> LoadAsync(string path, bool loadFullI
                         // image already exists
                         img = ImageCache[key, loadFullImage] ?? img;
                     }
-                    else
+                    else if (cacheImage)
                     {
-                        // new guid
-
+                        // save guid key
                         GuidToKey[hash] = path;
                     }
                 }
 
-                // update cache
-                ImageCache[path, loadFullImage] = img;
+                if (cacheImage)
+                {
+                    // update cache
+                    ImageCache[path, loadFullImage] = img;
+                }
             }
 
             return img;

Flow.Launcher.Infrastructure/Logger/Log.cs

@@ -1,12 +1,12 @@
 using System.Diagnostics;
 using System.IO;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using Flow.Launcher.Infrastructure.UserSettings;
 using NLog;
 using NLog.Config;
 using NLog.Targets;
-using Flow.Launcher.Infrastructure.UserSettings;
 using NLog.Targets.Wrappers;
-using System.Runtime.ExceptionServices;
 
 namespace Flow.Launcher.Infrastructure.Logger
 {

Flow.Launcher.Infrastructure/Storage/BinaryStorage.cs

@@ -2,62 +2,76 @@
 using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
+using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedCommands;
 using MemoryPack;
 
+#nullable enable
+
 namespace Flow.Launcher.Infrastructure.Storage
 {
     /// <summary>
     /// Stroage object using binary data
     /// Normally, it has better performance, but not readable
     /// </summary>
     /// <remarks>
-    /// It utilize MemoryPack, which means the object must be MemoryPackSerializable <see href="https://github.com/Cysharp/MemoryPack"/>
+    /// It utilizes MemoryPack, which means the object must be MemoryPackSerializable <see href="https://github.com/Cysharp/MemoryPack"/>
     /// </remarks>
-    public class BinaryStorage<T>
+    public class BinaryStorage<T> : ISavable
     {
+        protected T? Data;
+
         public const string FileSuffix = ".cache";
 
+        protected string FilePath { get; init; } = null!;
+
+        protected string DirectoryPath { get; init; } = null!;
+
         // Let the derived class to set the file path
-        public BinaryStorage(string filename, string directoryPath = null)
+        protected BinaryStorage()
         {
-            directoryPath ??= DataLocation.CacheDirectory;
-            FilesFolders.ValidateDirectory(directoryPath);
-
-            FilePath = Path.Combine(directoryPath, $"{filename}{FileSuffix}");
         }
 
-        public string FilePath { get; }
+        public BinaryStorage(string filename)
+        {
+            DirectoryPath = DataLocation.CacheDirectory;
+            FilesFolders.ValidateDirectory(DirectoryPath);
+
+            FilePath = Path.Combine(DirectoryPath, $"{filename}{FileSuffix}");
+        }
 
         public async ValueTask<T> TryLoadAsync(T defaultData)
         {
+            if (Data != null) return Data;
+
             if (File.Exists(FilePath))
             {
                 if (new FileInfo(FilePath).Length == 0)
                 {
                     Log.Error($"|BinaryStorage.TryLoad|Zero length cache file <{FilePath}>");
-                    await SaveAsync(defaultData);
-                    return defaultData;
+                    Data = defaultData;
+                    await SaveAsync();
                 }
 
                 await using var stream = new FileStream(FilePath, FileMode.Open);
-                var d = await DeserializeAsync(stream, defaultData);
-                return d;
+                Data = await DeserializeAsync(stream, defaultData);
             }
             else
             {
                 Log.Info("|BinaryStorage.TryLoad|Cache file not exist, load default data");
-                await SaveAsync(defaultData);
-                return defaultData;
+                Data = defaultData;
+                await SaveAsync();
             }
+
+            return Data;
         }
 
         private static async ValueTask<T> DeserializeAsync(Stream stream, T defaultData)
         {
             try
             {
                 var t = await MemoryPackSerializer.DeserializeAsync<T>(stream);
-                return t;
+                return t ?? defaultData;
             }
             catch (System.Exception)
             {
@@ -66,6 +80,27 @@ private static async ValueTask<T> DeserializeAsync(Stream stream, T defaultData)
             }
         }
 
+        public void Save()
+        {
+            var serialized = MemoryPackSerializer.Serialize(Data);
+
+            File.WriteAllBytes(FilePath, serialized);
+        }
+
+        public async ValueTask SaveAsync()
+        {
+            await SaveAsync(Data.NonNull());
+        }
+
+        // ImageCache need to convert data into concurrent dictionary for usage,
+        // so we would better to clear the data
+        public void ClearData()
+        {
+            Data = default;
+        }
+
+        // ImageCache storages data in its class,
+        // so we need to pass it to SaveAsync
         public async ValueTask SaveAsync(T data)
         {
             await using var stream = new FileStream(FilePath, FileMode.Create);