Improved log message display

v2rayN/ServiceLib/Enums/EViewAction.cs

@@ -39,6 +39,7 @@
         DispatcherRefreshServersBiz,
         DispatcherRefreshIcon,
         DispatcherCheckUpdate,
-        DispatcherCheckUpdateFinished,       
+        DispatcherCheckUpdateFinished, 
+        DispatcherShowMsg,
     }
 }

v2rayN/ServiceLib/Handler/ConfigHandler.cs

@@ -124,20 +124,16 @@ namespace ServiceLib.Handler
                     mtu = 9000,
                 };
             }
-            if (config.guiItem == null)
+            config.guiItem ??= new()
             {
-                config.guiItem = new()
-                {
-                    enableStatistics = false,
-                };
-            }
-            if (config.uiItem == null)
+                enableStatistics = false,
+            };
+            config.msgUIItem ??= new();
+
+            config.uiItem ??= new UIItem()
             {
-                config.uiItem = new UIItem()
-                {
-                    enableAutoAdjustMainLvColWidth = true
-                };
-            }
+                enableAutoAdjustMainLvColWidth = true
+            };
             if (config.uiItem.mainColumnItem == null)
             {
                 config.uiItem.mainColumnItem = new();
@@ -174,11 +170,11 @@ namespace ServiceLib.Handler
             }
 
             config.mux4RayItem ??= new()
-                {
-                    concurrency = 8,
-                    xudpConcurrency = 16,
-                    xudpProxyUDP443 = "reject"
-                };
+            {
+                concurrency = 8,
+                xudpConcurrency = 16,
+                xudpProxyUDP443 = "reject"
+            };
 
             if (config.mux4SboxItem == null)
             {

v2rayN/ServiceLib/Models/Config.cs

@@ -38,6 +38,7 @@
         public GrpcItem grpcItem { get; set; }
         public RoutingBasicItem routingBasicItem { get; set; }
         public GUIItem guiItem { get; set; }
+        public MsgUIItem msgUIItem { get; set; }
         public UIItem uiItem { get; set; }
         public ConstItem constItem { get; set; }
         public SpeedTestItem speedTestItem { get; set; }

v2rayN/ServiceLib/Models/ConfigItems.cs

@@ -107,6 +107,13 @@
         public bool enableLog { get; set; } = true;
     }
 
+    [Serializable]
+    public class MsgUIItem
+    {
+        public string? mainMsgFilter { get; set; }
+        public bool? autoRefresh { get; set; }
+    }
+
     [Serializable]
     public class UIItem
     {
@@ -126,7 +133,6 @@
         public bool enableDragDropSort { get; set; }
         public bool doubleClick2Activate { get; set; }
         public bool autoHideStartup { get; set; }
-        public string mainMsgFilter { get; set; }
         public List<ColumnItem> mainColumnItem { get; set; }
         public bool showInTaskbar { get; set; }
     }

v2rayN/ServiceLib/ViewModels/MsgViewModel.cs

@@ -0,0 +1,112 @@
+using ReactiveUI;
+using ReactiveUI.Fody.Helpers;
+using Splat;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+
+namespace ServiceLib.ViewModels
+{
+    public class MsgViewModel : MyReactiveObject
+    {
+        private ConcurrentQueue<string> _queueMsg = new();
+        private int _numMaxMsg = 500;
+        private string _lastMsgFilter = string.Empty;
+        private bool _lastMsgFilterNotAvailable;
+        private bool _blLockShow = false;
+
+        [Reactive]
+        public string MsgFilter { get; set; }
+
+        [Reactive]
+        public bool AutoRefresh { get; set; }
+
+        public MsgViewModel(Func<EViewAction, object?, Task<bool>>? updateView)
+        {
+            _config = LazyConfig.Instance.Config;
+            _updateView = updateView;
+            _noticeHandler = Locator.Current.GetService<NoticeHandler>();
+
+            MessageBus.Current.Listen<string>(Global.CommandSendMsgView).Subscribe(async x => await AppendQueueMsg(x));
+
+            MsgFilter = _config.msgUIItem.mainMsgFilter ?? string.Empty;
+            AutoRefresh = _config.msgUIItem.autoRefresh ?? true;
+
+            this.WhenAnyValue(
+               x => x.MsgFilter)
+                   .Subscribe(c => _config.msgUIItem.mainMsgFilter = MsgFilter);
+
+            this.WhenAnyValue(
+              x => x.AutoRefresh,
+              y => y == true)
+                  .Subscribe(c => { _config.msgUIItem.autoRefresh = AutoRefresh; });
+        }
+
+        private async Task AppendQueueMsg(string msg)
+        {
+            //if (msg == Global.CommandClearMsg)
+            //{
+            //    ClearMsg();
+            //    return;
+            //}
+            if (AutoRefresh == false)
+            {
+                return;
+            }
+            _ = EnqueueQueueMsg(msg);
+
+            if (_blLockShow)
+            {
+                return;
+            }
+
+            _blLockShow = true;
+
+            await Task.Delay(100);
+            var txt = string.Join("", _queueMsg.ToArray());
+            await _updateView?.Invoke(EViewAction.DispatcherShowMsg, txt);
+
+            _blLockShow = false;
+        }
+
+        private async Task EnqueueQueueMsg(string msg)
+        {
+            //filter msg
+            if (MsgFilter != _lastMsgFilter) _lastMsgFilterNotAvailable = false;
+            if (!Utils.IsNullOrEmpty(MsgFilter) && !_lastMsgFilterNotAvailable)
+            {
+                try
+                {
+                    if (!Regex.IsMatch(msg, MsgFilter))
+                    {
+                        return;
+                    }
+                }
+                catch (Exception)
+                {
+                    _lastMsgFilterNotAvailable = true;
+                }
+            }
+            _lastMsgFilter = MsgFilter;
+
+            //Enqueue
+            if (_queueMsg.Count > _numMaxMsg)
+            {
+                for (int k = 0; k < _queueMsg.Count - _numMaxMsg; k++)
+                {
+                    _queueMsg.TryDequeue(out _);
+                }
+            }
+            _queueMsg.Enqueue(msg);
+            if (!msg.EndsWith(Environment.NewLine))
+            {
+                _queueMsg.Enqueue(Environment.NewLine);
+            }
+        }
+
+        public void ClearMsg()
+        {
+            _queueMsg.Clear();
+        }
+    }
+}