Merge pull request Flow-Launcher#3898 from Flow-Launcher/storage_api_method

Author: jjw24

Flow.Launcher.Infrastructure/Image/ImageLoader.cs

@@ -17,14 +17,14 @@ public static class ImageLoader
         private static readonly string ClassName = nameof(ImageLoader);
 
         private static readonly ImageCache ImageCache = new();
-        private static SemaphoreSlim storageLock { get; } = new SemaphoreSlim(1, 1);
+        private static Lock storageLock { get; } = new();
         private static BinaryStorage<List<(string, bool)>> _storage;
         private static readonly ConcurrentDictionary<string, string> GuidToKey = new();
         private static IImageHashGenerator _hashGenerator;
         private static readonly bool EnableImageHash = true;
-        public static ImageSource Image { get; } = new BitmapImage(new Uri(Constant.ImageIcon));
-        public static ImageSource MissingImage { get; } = new BitmapImage(new Uri(Constant.MissingImgIcon));
-        public static ImageSource LoadingImage { get; } = new BitmapImage(new Uri(Constant.LoadingImgIcon));
+        public static ImageSource Image => ImageCache[Constant.ImageIcon, false];
+        public static ImageSource MissingImage => ImageCache[Constant.MissingImgIcon, false];
+        public static ImageSource LoadingImage => ImageCache[Constant.LoadingImgIcon, false];
         public const int SmallIconSize = 64;
         public const int FullIconSize = 256;
         public const int FullImageSize = 320;
@@ -34,31 +34,29 @@ public static class ImageLoader
 
         public static async Task InitializeAsync()
         {
-            _storage = new BinaryStorage<List<(string, bool)>>("Image");
-            _hashGenerator = new ImageHashGenerator();
+            await Task.Run(() =>
+            {
+                _storage = new BinaryStorage<List<(string, bool)>>("Image");
+                _hashGenerator = new ImageHashGenerator();
 
-            // Even though we no longer do image preloading and thus don't need _storage,
-            // for some reason MemoryPackSerializer exceptions appear when this is removed
-            await LoadStorageToConcurrentDictionaryAsync();
+                // Even though we no longer do image preloading and thus don't need _storage,
+                // for some reason MemoryPackSerializer exceptions appear when this is removed
+                LoadStorageToConcurrentDictionary();
 
-            foreach (var icon in new[] { Constant.DefaultIcon, Constant.MissingImgIcon })
-            {
-                ImageSource img = new BitmapImage(new Uri(icon));
-                img.Freeze();
-                ImageCache[icon, false] = img;
-            }
+                foreach (var icon in new[] { Constant.DefaultIcon, Constant.ImageIcon, Constant.MissingImgIcon, Constant.LoadingImgIcon })
+                {
+                    ImageSource img = new BitmapImage(new Uri(icon));
+                    img.Freeze();
+                    ImageCache[icon, false] = img;
+                }
+            });
         }
 
-        private static async Task<List<(string, bool)>> LoadStorageToConcurrentDictionaryAsync()
+        private static List<(string, bool)> LoadStorageToConcurrentDictionary()
         {
-            await storageLock.WaitAsync();
-            try
-            {
-                return await _storage.TryLoadAsync(new List<(string, bool)>());
-            }
-            finally
+            lock (storageLock)
             {
-                storageLock.Release();
+                return _storage.TryLoad([]);
             }
         }
 
@@ -109,7 +107,7 @@ private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool
                 {
                     Log.Error(ClassName, $"Failed to load image from path {path}: Remote images are not supported.");
 
-                    ImageSource image = ImageCache[Constant.MissingImgIcon, false];
+                    ImageSource image = MissingImage;
                     ImageCache[path, false] = image;
                     imageResult = new ImageResult(image, ImageType.Error);
                 }
@@ -137,7 +135,7 @@ private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool
                     Log.Exception(ClassName, $"Failed to get thumbnail for {path} on first try", e);
                     Log.Exception(ClassName, $"Failed to get thumbnail for {path} on second try", e2);
 
-                    ImageSource image = ImageCache[Constant.MissingImgIcon, false];
+                    ImageSource image = MissingImage;
                     ImageCache[path, false] = image;
                     imageResult = new ImageResult(image, ImageType.Error);
                 }
@@ -205,7 +203,7 @@ private static ImageResult GetThumbnailResult(ref string path, bool loadFullImag
             }
             else
             {
-                image = ImageCache[Constant.MissingImgIcon, false];
+                image = MissingImage;
                 path = Constant.MissingImgIcon;
             }
 

Flow.Launcher.Infrastructure/Storage/BinaryStorage.cs

@@ -12,7 +12,7 @@
 namespace Flow.Launcher.Infrastructure.Storage
 {
     /// <summary>
-    /// Stroage object using binary data
+    /// Storage object using binary data
     /// Normally, it has better performance, but not readable
     /// </summary>
     /// <remarks>
@@ -53,6 +53,45 @@ public BinaryStorage(string filename, string directoryPath = null!)
             FilePath = Path.Combine(DirectoryPath, $"{filename}{FileSuffix}");
         }
 
+        public T TryLoad(T defaultData)
+        {
+            if (Data != null) return Data;
+
+            if (File.Exists(FilePath))
+            {
+                if (new FileInfo(FilePath).Length == 0)
+                {
+                    Log.Error(ClassName, $"Zero length cache file <{FilePath}>");
+                    Data = defaultData;
+                    Save();
+                }
+
+                var bytes = File.ReadAllBytes(FilePath);
+                Data = Deserialize(bytes, defaultData);
+            }
+            else
+            {
+                Log.Info(ClassName, "Cache file not exist, load default data");
+                Data = defaultData;
+                Save();
+            }
+            return Data;
+        }
+
+        private T Deserialize(ReadOnlySpan<byte> bytes, T defaultData)
+        {
+            try
+            {
+                var t = MemoryPackSerializer.Deserialize<T>(bytes);
+                return t ?? defaultData;
+            }
+            catch (System.Exception e)
+            {
+                Log.Exception(ClassName, $"Deserialize error for file <{FilePath}>", e);
+                return defaultData;
+            }
+        }
+
         public async ValueTask<T> TryLoadAsync(T defaultData)
         {
             if (Data != null) return Data;
@@ -79,26 +118,31 @@ public async ValueTask<T> TryLoadAsync(T defaultData)
             return Data;
         }
 
-        private static async ValueTask<T> DeserializeAsync(Stream stream, T defaultData)
+        private async ValueTask<T> DeserializeAsync(Stream stream, T defaultData)
         {
             try
             {
                 var t = await MemoryPackSerializer.DeserializeAsync<T>(stream);
                 return t ?? defaultData;
             }
-            catch (System.Exception)
+            catch (System.Exception e)
             {
-                // Log.Exception($"|BinaryStorage.Deserialize|Deserialize error for file <{FilePath}>", e);
+                Log.Exception(ClassName, $"Deserialize error for file <{FilePath}>", e);
                 return defaultData;
             }
         }
 
         public void Save()
+        {
+            Save(Data.NonNull());
+        }
+
+        public void Save(T data)
         {
             // User may delete the directory, so we need to check it
             FilesFolders.ValidateDirectory(DirectoryPath);
 
-            var serialized = MemoryPackSerializer.Serialize(Data);
+            var serialized = MemoryPackSerializer.Serialize(data);
             File.WriteAllBytes(FilePath, serialized);
         }
 
@@ -107,15 +151,6 @@ 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)
         {
             // User may delete the directory, so we need to check it
@@ -124,5 +159,12 @@ public async ValueTask SaveAsync(T data)
             await using var stream = new FileStream(FilePath, FileMode.Create);
             await MemoryPackSerializer.SerializeAsync(stream, data);
         }
+
+        // ImageCache need to convert data into concurrent dictionary for usage,
+        // so we would better to clear the data
+        public void ClearData()
+        {
+            Data = default;
+        }
     }
 }

Flow.Launcher/PublicAPIInstance.cs

@@ -68,7 +68,7 @@ public void ChangeQuery(string query, bool requery = false)
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "VSTHRD100:Avoid async void methods", Justification = "<Pending>")]
-        public async void RestartApp()
+        public void RestartApp()
         {
             _mainVM.Hide();