Merge pull request Flow-Launcher#4011 from Flow-Launcher/flow_launcher_localization1

Use Flow.Launcher.Localization to improve code quality

Author: Jack251970

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

@@ -32,6 +32,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <Prefer32Bit>false</Prefer32Bit>
+    <NoWarn>$(NoWarn);FLSG0007</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
@@ -52,12 +53,24 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Flow.Launcher.Localization" Version="0.0.6" />
     <PackageReference Include="Meziantou.Framework.Win32.Jobs" Version="3.4.5" />
     <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.1" />
     <PackageReference Include="StreamJsonRpc" Version="2.22.11" />
     <PackageReference Include="YamlDotNet" Version="16.3.0" />
   </ItemGroup>
-  
+
+  <PropertyGroup>
+    <FLLUseDependencyInjection>true</FLLUseDependencyInjection>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <AdditionalFiles Remove="Languages\en.xaml" />
+    <AdditionalFiles Include="..\Flow.Launcher\Languages\en.xaml">
+      <Link>Languages\en.xaml</Link>
+    </AdditionalFiles>
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Flow.Launcher.Infrastructure\Flow.Launcher.Infrastructure.csproj" />
     <ProjectReference Include="..\Flow.Launcher.Plugin\Flow.Launcher.Plugin.csproj" />

Flow.Launcher.Core/Plugin/JsonRPCPluginSettings.cs

@@ -286,7 +286,7 @@ public Control CreateSettingPanel()
                                 HorizontalAlignment = HorizontalAlignment.Left,
                                 VerticalAlignment = VerticalAlignment.Center,
                                 Margin = SettingPanelItemLeftMargin,
-                                Content = API.GetTranslation("select")
+                                Content = Localize.select()
                             };
 
                             Btn.Click += (_, _) =>

Flow.Launcher.Core/Plugin/PluginConfig.cs

@@ -5,18 +5,13 @@
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Plugin;
 using System.Text.Json;
-using CommunityToolkit.Mvvm.DependencyInjection;
 
 namespace Flow.Launcher.Core.Plugin
 {
     internal abstract class PluginConfig
     {
         private static readonly string ClassName = nameof(PluginConfig);
 
-        // We should not initialize API in static constructor because it will create another API instance
-        private static IPublicAPI api = null;
-        private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();
-
         /// <summary>
         /// Parse plugin metadata in the given directories
         /// </summary>
@@ -38,7 +33,7 @@ public static List<PluginMetadata> Parse(string[] pluginDirectories)
                     }
                     catch (Exception e)
                     {
-                        API.LogException(ClassName, $"Can't delete <{directory}>", e);
+                        PublicApi.Instance.LogException(ClassName, $"Can't delete <{directory}>", e);
                     }
                 }
                 else
@@ -55,7 +50,7 @@ public static List<PluginMetadata> Parse(string[] pluginDirectories)
 
             duplicateList
                 .ForEach(
-                    x => API.LogWarn(ClassName, 
+                    x => PublicApi.Instance.LogWarn(ClassName, 
                         string.Format("Duplicate plugin name: {0}, id: {1}, version: {2} " +
                             "not loaded due to version not the highest of the duplicates",
                             x.Name, x.ID, x.Version),
@@ -107,7 +102,7 @@ private static PluginMetadata GetPluginMetadata(string pluginDirectory)
             string configPath = Path.Combine(pluginDirectory, Constant.PluginMetadataFileName);
             if (!File.Exists(configPath))
             {
-                API.LogError(ClassName, $"Didn't find config file <{configPath}>");
+                PublicApi.Instance.LogError(ClassName, $"Didn't find config file <{configPath}>");
                 return null;
             }
 
@@ -123,19 +118,19 @@ private static PluginMetadata GetPluginMetadata(string pluginDirectory)
             }
             catch (Exception e)
             {
-                API.LogException(ClassName, $"Invalid json for config <{configPath}>", e);
+                PublicApi.Instance.LogException(ClassName, $"Invalid json for config <{configPath}>", e);
                 return null;
             }
 
             if (!AllowedLanguage.IsAllowed(metadata.Language))
             {
-                API.LogError(ClassName, $"Invalid language <{metadata.Language}> for config <{configPath}>");
+                PublicApi.Instance.LogError(ClassName, $"Invalid language <{metadata.Language}> for config <{configPath}>");
                 return null;
             }
 
             if (!File.Exists(metadata.ExecuteFilePath))
             {
-                API.LogError(ClassName, $"Execute file path didn't exist <{metadata.ExecuteFilePath}> for conifg <{configPath}");
+                PublicApi.Instance.LogError(ClassName, $"Execute file path didn't exist <{metadata.ExecuteFilePath}> for conifg <{configPath}");
                 return null;
             }
 

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -5,7 +5,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using CommunityToolkit.Mvvm.DependencyInjection;
 using Flow.Launcher.Core.ExternalPlugins;
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Infrastructure.UserSettings;
@@ -25,10 +24,6 @@ public static class PluginManager
         public static readonly HashSet<PluginPair> GlobalPlugins = new();
         public static readonly Dictionary<string, PluginPair> NonGlobalPlugins = new();
 
-        // We should not initialize API in static constructor because it will create another API instance
-        private static IPublicAPI api = null;
-        private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();
-
         private static PluginsSettings Settings;
 
         private static IEnumerable<PluginPair> _contextMenuPlugins;
@@ -58,12 +53,12 @@ public static void Save()
                 }
                 catch (Exception e)
                 {
-                    API.LogException(ClassName, $"Failed to save plugin {pluginPair.Metadata.Name}", e);
+                    PublicApi.Instance.LogException(ClassName, $"Failed to save plugin {pluginPair.Metadata.Name}", e);
                 }
             }
 
-            API.SavePluginSettings();
-            API.SavePluginCaches();
+            PublicApi.Instance.SavePluginSettings();
+            PublicApi.Instance.SavePluginCaches();
         }
 
         public static async ValueTask DisposePluginsAsync()
@@ -90,7 +85,7 @@ private static async Task DisposePluginAsync(PluginPair pluginPair)
             }
             catch (Exception e)
             {
-                API.LogException(ClassName, $"Failed to dispose plugin {pluginPair.Metadata.Name}", e);
+                PublicApi.Instance.LogException(ClassName, $"Failed to dispose plugin {pluginPair.Metadata.Name}", e);
             }
         }
 
@@ -181,7 +176,7 @@ private static void UpdatePluginDirectory(List<PluginMetadata> metadatas)
                 {
                     if (string.IsNullOrEmpty(metadata.AssemblyName))
                     {
-                        API.LogWarn(ClassName, $"AssemblyName is empty for plugin with metadata: {metadata.Name}");
+                        PublicApi.Instance.LogWarn(ClassName, $"AssemblyName is empty for plugin with metadata: {metadata.Name}");
                         continue; // Skip if AssemblyName is not set, which can happen for erroneous plugins
                     }
                     metadata.PluginSettingsDirectoryPath = Path.Combine(DataLocation.PluginSettingsDirectory, metadata.AssemblyName);
@@ -191,7 +186,7 @@ private static void UpdatePluginDirectory(List<PluginMetadata> metadatas)
                 {
                     if (string.IsNullOrEmpty(metadata.Name))
                     {
-                        API.LogWarn(ClassName, $"Name is empty for plugin with metadata: {metadata.Name}");
+                        PublicApi.Instance.LogWarn(ClassName, $"Name is empty for plugin with metadata: {metadata.Name}");
                         continue; // Skip if Name is not set, which can happen for erroneous plugins
                     }
                     metadata.PluginSettingsDirectoryPath = Path.Combine(DataLocation.PluginSettingsDirectory, metadata.Name);
@@ -212,28 +207,28 @@ public static async Task InitializePluginsAsync()
             {
                 try
                 {
-                    var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Init method time cost for <{pair.Metadata.Name}>",
-                        () => pair.Plugin.InitAsync(new PluginInitContext(pair.Metadata, API)));
+                    var milliseconds = await PublicApi.Instance.StopwatchLogDebugAsync(ClassName, $"Init method time cost for <{pair.Metadata.Name}>",
+                        () => pair.Plugin.InitAsync(new PluginInitContext(pair.Metadata, PublicApi.Instance)));
 
                     pair.Metadata.InitTime += milliseconds;
-                    API.LogInfo(ClassName,
+                    PublicApi.Instance.LogInfo(ClassName,
                         $"Total init cost for <{pair.Metadata.Name}> is <{pair.Metadata.InitTime}ms>");
                 }
                 catch (Exception e)
                 {
-                    API.LogException(ClassName, $"Fail to Init plugin: {pair.Metadata.Name}", e);
+                    PublicApi.Instance.LogException(ClassName, $"Fail to Init plugin: {pair.Metadata.Name}", e);
                     if (pair.Metadata.Disabled && pair.Metadata.HomeDisabled)
                     {
                         // If this plugin is already disabled, do not show error message again
                         // Or else it will be shown every time
-                        API.LogDebug(ClassName, $"Skipped init for <{pair.Metadata.Name}> due to error");
+                        PublicApi.Instance.LogDebug(ClassName, $"Skipped init for <{pair.Metadata.Name}> due to error");
                     }
                     else
                     {
                         pair.Metadata.Disabled = true;
                         pair.Metadata.HomeDisabled = true;
                         failedPlugins.Enqueue(pair);
-                        API.LogDebug(ClassName, $"Disable plugin <{pair.Metadata.Name}> because init failed");
+                        PublicApi.Instance.LogDebug(ClassName, $"Disable plugin <{pair.Metadata.Name}> because init failed");
                     }
                 }
             }));
@@ -258,15 +253,12 @@ public static async Task InitializePluginsAsync()
                 }
             }
 
-            if (failedPlugins.Any())
+            if (!failedPlugins.IsEmpty)
             {
                 var failed = string.Join(",", failedPlugins.Select(x => x.Metadata.Name));
-                API.ShowMsg(
-                    API.GetTranslation("failedToInitializePluginsTitle"),
-                    string.Format(
-                        API.GetTranslation("failedToInitializePluginsMessage"),
-                        failed
-                    ),
+                PublicApi.Instance.ShowMsg(
+                    Localize.failedToInitializePluginsTitle(),
+                    Localize.failedToInitializePluginsMessage(failed),
                     "",
                     false
                 );
@@ -301,7 +293,7 @@ public static async Task<List<Result>> QueryForPluginAsync(PluginPair pair, Quer
 
             try
             {
-                var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Cost for {metadata.Name}",
+                var milliseconds = await PublicApi.Instance.StopwatchLogDebugAsync(ClassName, $"Cost for {metadata.Name}",
                     async () => results = await pair.Plugin.QueryAsync(query, token).ConfigureAwait(false));
 
                 token.ThrowIfCancellationRequested();
@@ -345,7 +337,7 @@ public static async Task<List<Result>> QueryHomeForPluginAsync(PluginPair pair,
 
             try
             {
-                var milliseconds = await API.StopwatchLogDebugAsync(ClassName, $"Cost for {metadata.Name}",
+                var milliseconds = await PublicApi.Instance.StopwatchLogDebugAsync(ClassName, $"Cost for {metadata.Name}",
                     async () => results = await ((IAsyncHomeQuery)pair.Plugin).HomeQueryAsync(token).ConfigureAwait(false));
 
                 token.ThrowIfCancellationRequested();
@@ -362,7 +354,7 @@ public static async Task<List<Result>> QueryHomeForPluginAsync(PluginPair pair,
             }
             catch (Exception e)
             {
-                API.LogException(ClassName, $"Failed to query home for plugin: {metadata.Name}", e);
+                PublicApi.Instance.LogException(ClassName, $"Failed to query home for plugin: {metadata.Name}", e);
                 return null;
             }
             return results;
@@ -429,7 +421,7 @@ public static List<Result> GetContextMenusForPlugin(Result result)
                 }
                 catch (Exception e)
                 {
-                    API.LogException(ClassName,
+                    PublicApi.Instance.LogException(ClassName,
                         $"Can't load context menus for plugin <{pluginPair.Metadata.Name}>",
                         e);
                 }

Flow.Launcher.Core/Plugin/PluginsLoader.cs

@@ -2,9 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Threading.Tasks;
-using System.Windows;
-using CommunityToolkit.Mvvm.DependencyInjection;
 #pragma warning disable IDE0005
 using Flow.Launcher.Infrastructure.Logger;
 #pragma warning restore IDE0005
@@ -17,10 +14,6 @@ public static class PluginsLoader
     {
         private static readonly string ClassName = nameof(PluginsLoader);
 
-        // We should not initialize API in static constructor because it will create another API instance
-        private static IPublicAPI api = null;
-        private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();
-
         public static List<PluginPair> Plugins(List<PluginMetadata> metadatas, PluginsSettings settings)
         {
             var dotnetPlugins = DotNetPlugins(metadatas);
@@ -44,7 +37,7 @@ private static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source
 
             foreach (var metadata in metadatas)
             {
-                var milliseconds = API.StopwatchLogDebug(ClassName, $"Constructor init cost for {metadata.Name}", () =>
+                var milliseconds = PublicApi.Instance.StopwatchLogDebug(ClassName, $"Constructor init cost for {metadata.Name}", () =>
                     {
                         Assembly assembly = null;
                         IAsyncPlugin plugin = null;
@@ -69,19 +62,19 @@ private static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source
 #else
                         catch (Exception e) when (assembly == null)
                         {
-                            Log.Exception(ClassName, $"Couldn't load assembly for the plugin: {metadata.Name}", e);
+                            PublicApi.Instance.LogException(ClassName, $"Couldn't load assembly for the plugin: {metadata.Name}", e);
                         }
                         catch (InvalidOperationException e)
                         {
-                            Log.Exception(ClassName, $"Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
+                            PublicApi.Instance.LogException(ClassName, $"Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
                         }
                         catch (ReflectionTypeLoadException e)
                         {
-                            Log.Exception(ClassName, $"The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
+                            PublicApi.Instance.LogException(ClassName, $"The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
                         }
                         catch (Exception e)
                         {
-                            Log.Exception(ClassName, $"The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
+                            PublicApi.Instance.LogException(ClassName, $"The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
                         }
 #endif
 
@@ -101,12 +94,12 @@ private static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source
                 var errorPluginString = string.Join(Environment.NewLine, erroredPlugins);
 
                 var errorMessage = erroredPlugins.Count > 1 ?
-                    API.GetTranslation("pluginsHaveErrored") :
-                    API.GetTranslation("pluginHasErrored");
+                    Localize.pluginsHaveErrored() :
+                    Localize.pluginHasErrored();
 
-                API.ShowMsgError($"{errorMessage}{Environment.NewLine}{Environment.NewLine}" +
+                PublicApi.Instance.ShowMsgError($"{errorMessage}{Environment.NewLine}{Environment.NewLine}" +
                     $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
-                    API.GetTranslation("referToLogs"));
+                    Localize.referToLogs());
             }
 
             return plugins;