zishuo/Archive
1
0
Fork 0
mirror of https://github.com/bolucat/Archive.git synced 2026-04-23 00:17:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update On Sat Oct 12 20:33:04 CEST 2024

Browse Source
This commit is contained in:
github-action[bot]
2024-10-12 20:33:05 +02:00
parent 560bea1331
commit 69775b913f
507 changed files with 29881 additions and 2648 deletions
Download Patch File Download Diff File Expand all files Collapse all files
v2rayn/v2rayN/ServiceLib/ViewModels/MainWindowViewModel.cs
+36 -440
View File
@@ -1,41 +1,14 @@
using DynamicData.Binding;
using ReactiveUI;
using ReactiveUI.Fody.Helpers;
using Splat;
using System.Diagnostics;
using System.Reactive;
using System.Reactive.Linq;
using System.Text;
namespace ServiceLib.ViewModels
{
public class MainWindowViewModel : MyReactiveObject
{
#region private prop
private bool _isAdministrator { get; set; }
#endregion private prop
#region ObservableCollection
private IObservableCollection<RoutingItem> _routingItems = new ObservableCollectionExtended<RoutingItem>();
public IObservableCollection<RoutingItem> RoutingItems => _routingItems;
private IObservableCollection<ComboItem> _servers = new ObservableCollectionExtended<ComboItem>();
public IObservableCollection<ComboItem> Servers => _servers;
[Reactive]
public RoutingItem SelectedRouting { get; set; }
[Reactive]
public ComboItem SelectedServer { get; set; }
[Reactive]
public bool BlServers { get; set; }
#endregion ObservableCollection
#region Menu
//servers
@@ -76,120 +49,27 @@ namespace ServiceLib.ViewModels
[Reactive]
public bool BlReloadEnabled { get; set; }
public ReactiveCommand<Unit, Unit> NotifyLeftClickCmd { get; }
#endregion Menu
#region System Proxy
[Reactive]
public bool BlSystemProxyClear { get; set; }
[Reactive]
public bool BlSystemProxySet { get; set; }
[Reactive]
public bool BlSystemProxyNothing { get; set; }
[Reactive]
public bool BlSystemProxyPac { get; set; }
public ReactiveCommand<Unit, Unit> SystemProxyClearCmd { get; }
public ReactiveCommand<Unit, Unit> SystemProxySetCmd { get; }
public ReactiveCommand<Unit, Unit> SystemProxyNothingCmd { get; }
public ReactiveCommand<Unit, Unit> SystemProxyPacCmd { get; }
[Reactive]
public bool BlRouting { get; set; }
[Reactive]
public int SystemProxySelected { get; set; }
#endregion System Proxy
#region UI
[Reactive]
public string InboundDisplay { get; set; }
[Reactive]
public string InboundLanDisplay { get; set; }
[Reactive]
public string RunningServerDisplay { get; set; }
[Reactive]
public string RunningServerToolTipText { get; set; }
[Reactive]
public string RunningInfoDisplay { get; set; }
[Reactive]
public string SpeedProxyDisplay { get; set; }
[Reactive]
public string SpeedDirectDisplay { get; set; }
[Reactive]
public bool EnableTun { get; set; }
[Reactive]
public bool ShowClashUI { get; set; }
[Reactive]
public int TabMainSelectedIndex { get; set; }
#endregion UI
#endregion Menu
#region Init
public MainWindowViewModel(bool isAdministrator, Func<EViewAction, object?, Task<bool>>? updateView)
public MainWindowViewModel(Func<EViewAction, object?, Task<bool>>? updateView)
{
_config = AppHandler.Instance.Config;
_updateView = updateView;
_isAdministrator = isAdministrator;
MessageBus.Current.Listen<string>(EMsgCommand.RefreshProfiles.ToString()).Subscribe(async x => await _updateView?.Invoke(EViewAction.DispatcherRefreshServersBiz, null));
SelectedRouting = new();
SelectedServer = new();
Init();
_config.uiItem.showInTaskbar = true;
if (_config.tunModeItem.enableTun && _isAdministrator)
{
EnableTun = true;
}
else
{
_config.tunModeItem.enableTun = EnableTun = false;
}
#region WhenAnyValue && ReactiveCommand
this.WhenAnyValue(
x => x.SelectedRouting,
y => y != null && !y.remarks.IsNullOrEmpty())
.Subscribe(c => RoutingSelectedChangedAsync(c));
this.WhenAnyValue(
x => x.SelectedServer,
y => y != null && !y.Text.IsNullOrEmpty())
.Subscribe(c => ServerSelectedChanged(c));
SystemProxySelected = (int)_config.systemProxyItem.sysProxyType;
this.WhenAnyValue(
x => x.SystemProxySelected,
y => y >= 0)
.Subscribe(c => DoSystemProxySelected(c));
this.WhenAnyValue(
x => x.EnableTun,
y => y == true)
.Subscribe(c => DoEnableTun(c));
//servers
AddVmessServerCmd = ReactiveCommand.CreateFromTask(async () =>
{
@@ -237,7 +117,7 @@ namespace ServiceLib.ViewModels
});
AddServerViaScanCmd = ReactiveCommand.CreateFromTask(async () =>
{
await _updateView?.Invoke(EViewAction.ScanScreenTask, null);
await AddServerViaScanTaskAsync();
});
//Subscription
@@ -301,29 +181,6 @@ namespace ServiceLib.ViewModels
await Reload();
});
NotifyLeftClickCmd = ReactiveCommand.CreateFromTask(async () =>
{
await _updateView?.Invoke(EViewAction.ShowHideWindow, null);
});
//System proxy
SystemProxyClearCmd = ReactiveCommand.CreateFromTask(async () =>
{
await SetListenerType(ESysProxyType.ForcedClear);
});
SystemProxySetCmd = ReactiveCommand.CreateFromTask(async () =>
{
await SetListenerType(ESysProxyType.ForcedChange);
});
SystemProxyNothingCmd = ReactiveCommand.CreateFromTask(async () =>
{
await SetListenerType(ESysProxyType.Unchanged);
});
SystemProxyPacCmd = ReactiveCommand.CreateFromTask(async () =>
{
await SetListenerType(ESysProxyType.Pac);
});
#endregion WhenAnyValue && ReactiveCommand
AutoHideStartup();
@@ -334,18 +191,14 @@ namespace ServiceLib.ViewModels
ConfigHandler.InitBuiltinRouting(_config);
ConfigHandler.InitBuiltinDNS(_config);
CoreHandler.Instance.Init(_config, UpdateHandler);
TaskHandler.Instance.RegUpdateTask(_config, UpdateTaskHandler);
if (_config.guiItem.enableStatistics)
{
StatisticsHandler.Instance.Init(_config, UpdateStatisticsHandler);
}
TaskHandler.Instance.RegUpdateTask(_config, UpdateTaskHandler);
RefreshRoutingsMenu();
//RefreshServers();
Reload();
ChangeSystemProxyStatusAsync(_config.systemProxyItem.sysProxyType, true);
}
#endregion Init
@@ -392,9 +245,7 @@ namespace ServiceLib.ViewModels
{
try
{
SpeedProxyDisplay = string.Format(ResUI.SpeedDisplayText, Global.ProxyTag, Utils.HumanFy(update.proxyUp), Utils.HumanFy(update.proxyDown));
SpeedDirectDisplay = string.Format(ResUI.SpeedDisplayText, Global.DirectTag, Utils.HumanFy(update.directUp), Utils.HumanFy(update.directDown));
Locator.Current.GetService<StatusBarViewModel>()?.UpdateStatistics(update);
if ((update.proxyUp + update.proxyDown) > 0 && DateTime.Now.Second % 3 == 0)
{
Locator.Current.GetService<ProfilesViewModel>()?.UpdateStatistics(update);
@@ -447,6 +298,11 @@ namespace ServiceLib.ViewModels
}
}
public void ShowHideWindow(bool? blShow)
{
_updateView?.Invoke(EViewAction.ShowHideWindow, blShow);
}
#endregion Actions
#region Servers && Groups
@@ -456,50 +312,6 @@ namespace ServiceLib.ViewModels
MessageBus.Current.SendMessage("", EMsgCommand.RefreshProfiles.ToString());
}
public void RefreshServersBiz()
{
RefreshServersMenu();
//display running server
var running = ConfigHandler.GetDefaultServer(_config);
if (running != null)
{
RunningServerDisplay =
RunningServerToolTipText = running.GetSummary();
}
else
{
RunningServerDisplay =
RunningServerToolTipText = ResUI.CheckServerSettings;
}
}
private void RefreshServersMenu()
{
var lstModel = AppHandler.Instance.ProfileItems(_config.subIndexId, "");
_servers.Clear();
if (lstModel.Count > _config.guiItem.trayMenuServersLimit)
{
BlServers = false;
return;
}
BlServers = true;
for (int k = 0; k < lstModel.Count; k++)
{
ProfileItem it = lstModel[k];
string name = it.GetSummary();
var item = new ComboItem() { ID = it.indexId, Text = name };
_servers.Add(item);
if (_config.indexId == it.indexId)
{
SelectedServer = item;
}
}
}
private void RefreshSubscriptions()
{
Locator.Current.GetService<ProfilesViewModel>()?.RefreshSubscriptions();
@@ -553,7 +365,12 @@ namespace ServiceLib.ViewModels
}
}
public void ScanScreenTaskAsync(string result)
public async Task AddServerViaScanTaskAsync()
{
_updateView?.Invoke(EViewAction.ScanScreenTask, null);
}
public void ScanScreenResult(string result)
{
if (Utils.IsNullOrEmpty(result))
{
@@ -571,66 +388,6 @@ namespace ServiceLib.ViewModels
}
}
private void SetDefaultServer(string indexId)
{
if (Utils.IsNullOrEmpty(indexId))
{
return;
}
if (indexId == _config.indexId)
{
return;
}
var item = AppHandler.Instance.GetProfileItem(indexId);
if (item is null)
{
NoticeHandler.Instance.Enqueue(ResUI.PleaseSelectServer);
return;
}
if (ConfigHandler.SetDefaultServerIndex(_config, indexId) == 0)
{
RefreshServers();
Reload();
}
}
private void ServerSelectedChanged(bool c)
{
if (!c)
{
return;
}
if (SelectedServer == null)
{
return;
}
if (Utils.IsNullOrEmpty(SelectedServer.ID))
{
return;
}
SetDefaultServer(SelectedServer.ID);
}
public async Task TestServerAvailability()
{
var item = ConfigHandler.GetDefaultServer(_config);
if (item == null)
{
return;
}
await (new UpdateService()).RunAvailabilityCheck(async (bool success, string msg) =>
{
NoticeHandler.Instance.SendMessageEx(msg);
_updateView?.Invoke(EViewAction.DispatcherServerAvailability, msg);
});
}
public void TestServerAvailabilityResult(string msg)
{
RunningInfoDisplay = msg;
}
#endregion Add Servers
#region Subscription
@@ -657,7 +414,7 @@ namespace ServiceLib.ViewModels
var ret = await _updateView?.Invoke(EViewAction.OptionSettingWindow, null);
if (ret == true)
{
//RefreshServers();
Locator.Current.GetService<StatusBarViewModel>()?.InboundDisplayStaus();
Reload();
}
}
@@ -668,8 +425,7 @@ namespace ServiceLib.ViewModels
if (ret == true)
{
ConfigHandler.InitBuiltinRouting(_config);
RefreshRoutingsMenu();
//RefreshServers();
Locator.Current.GetService<StatusBarViewModel>()?.RefreshRoutingsMenu();
Reload();
}
}
@@ -683,20 +439,20 @@ namespace ServiceLib.ViewModels
}
}
private async Task RebootAsAdmin()
public async Task RebootAsAdmin()
{
ProcessStartInfo startInfo = new()
{
UseShellExecute = true,
Arguments = Global.RebootAs,
WorkingDirectory = Utils.StartupPath(),
FileName = Utils.GetExePath().AppendQuotes(),
Verb = "runas",
};
try
{
ProcessStartInfo startInfo = new()
{
UseShellExecute = true,
Arguments = Global.RebootAs,
WorkingDirectory = Utils.StartupPath(),
FileName = Utils.GetExePath().AppendQuotes(),
Verb = "runas",
};
Process.Start(startInfo);
MyAppExitAsync(false);
await MyAppExitAsync(false);
}
catch { }
}
@@ -728,13 +484,13 @@ namespace ServiceLib.ViewModels
BlReloadEnabled = false;
await LoadCore();
await TestServerAvailability();
Locator.Current.GetService<StatusBarViewModel>()?.TestServerAvailability();
_updateView?.Invoke(EViewAction.DispatcherReload, null);
}
public void ReloadResult()
{
ChangeSystemProxyStatusAsync(_config.systemProxyItem.sysProxyType, false);
//ChangeSystemProxyStatusAsync(_config.systemProxyItem.sysProxyType, false);
BlReloadEnabled = true;
ShowClashUI = _config.IsRunningCore(ECoreType.sing_box);
if (ShowClashUI)
@@ -762,182 +518,22 @@ namespace ServiceLib.ViewModels
public void CloseCore()
{
ConfigHandler.SaveConfig(_config, false);
ChangeSystemProxyStatusAsync(ESysProxyType.ForcedClear, false);
CoreHandler.Instance.CoreStop();
}
#endregion core job
#region System proxy and Routings
public async Task SetListenerType(ESysProxyType type)
{
if (_config.systemProxyItem.sysProxyType == type)
{
return;
}
_config.systemProxyItem.sysProxyType = type;
ChangeSystemProxyStatusAsync(type, true);
SystemProxySelected = (int)_config.systemProxyItem.sysProxyType;
ConfigHandler.SaveConfig(_config, false);
}
private async Task ChangeSystemProxyStatusAsync(ESysProxyType type, bool blChange)
{
//await _updateView?.Invoke(EViewAction.UpdateSysProxy, _config.tunModeItem.enableTun ? true : false);
_updateView?.Invoke(EViewAction.UpdateSysProxy, false);
NoticeHandler.Instance.SendMessageEx($"{ResUI.TipChangeSystemProxy} - {_config.systemProxyItem.sysProxyType.ToString()}");
BlSystemProxyClear = (type == ESysProxyType.ForcedClear);
BlSystemProxySet = (type == ESysProxyType.ForcedChange);
BlSystemProxyNothing = (type == ESysProxyType.Unchanged);
BlSystemProxyPac = (type == ESysProxyType.Pac);
InboundDisplayStaus();
if (blChange)
{
_updateView?.Invoke(EViewAction.DispatcherRefreshIcon, null);
}
}
private void RefreshRoutingsMenu()
{
_routingItems.Clear();
if (!_config.routingBasicItem.enableRoutingAdvanced)
{
BlRouting = false;
return;
}
BlRouting = true;
var routings = AppHandler.Instance.RoutingItems();
foreach (var item in routings)
{
_routingItems.Add(item);
if (item.id == _config.routingBasicItem.routingIndexId)
{
SelectedRouting = item;
}
}
}
private async Task RoutingSelectedChangedAsync(bool c)
{
if (!c)
{
return;
}
if (SelectedRouting == null)
{
return;
}
var item = AppHandler.Instance.GetRoutingItem(SelectedRouting?.id);
if (item is null)
{
return;
}
if (_config.routingBasicItem.routingIndexId == item.id)
{
return;
}
if (ConfigHandler.SetDefaultRouting(_config, item) == 0)
{
NoticeHandler.Instance.SendMessageEx(ResUI.TipChangeRouting);
Reload();
_updateView?.Invoke(EViewAction.DispatcherRefreshIcon, null);
}
}
private void DoSystemProxySelected(bool c)
{
if (!c)
{
return;
}
if (_config.systemProxyItem.sysProxyType == (ESysProxyType)SystemProxySelected)
{
return;
}
SetListenerType((ESysProxyType)SystemProxySelected);
}
private void DoEnableTun(bool c)
{
if (_config.tunModeItem.enableTun != EnableTun)
{
_config.tunModeItem.enableTun = EnableTun;
// When running as a non-administrator, reboot to administrator mode
if (EnableTun && !_isAdministrator)
{
_config.tunModeItem.enableTun = false;
RebootAsAdmin();
return;
}
ConfigHandler.SaveConfig(_config);
Reload();
}
}
#endregion System proxy and Routings
#region UI
public void InboundDisplayStaus()
{
StringBuilder sb = new();
sb.Append($"[{EInboundProtocol.socks}:{AppHandler.Instance.GetLocalPort(EInboundProtocol.socks)}]");
sb.Append(" | ");
//if (_config.systemProxyItem.sysProxyType == ESysProxyType.ForcedChange)
//{
// sb.Append($"[{Global.InboundHttp}({ResUI.SystemProxy}):{LazyConfig.Instance.GetLocalPort(Global.InboundHttp)}]");
//}
//else
//{
sb.Append($"[{EInboundProtocol.http}:{AppHandler.Instance.GetLocalPort(EInboundProtocol.http)}]");
//}
InboundDisplay = $"{ResUI.LabLocal}:{sb}";
if (_config.inbound[0].allowLANConn)
{
if (_config.inbound[0].newPort4LAN)
{
StringBuilder sb2 = new();
sb2.Append($"[{EInboundProtocol.socks}:{AppHandler.Instance.GetLocalPort(EInboundProtocol.socks2)}]");
sb2.Append(" | ");
sb2.Append($"[{EInboundProtocol.http}:{AppHandler.Instance.GetLocalPort(EInboundProtocol.http2)}]");
InboundLanDisplay = $"{ResUI.LabLAN}:{sb2}";
}
else
{
InboundLanDisplay = $"{ResUI.LabLAN}:{sb}";
}
}
else
{
InboundLanDisplay = $"{ResUI.LabLAN}:None";
}
}
private void AutoHideStartup()
{
if (_config.uiItem.autoHideStartup)
{
Observable.Range(1, 1)
.Delay(TimeSpan.FromSeconds(1))
.Subscribe(async x =>
{
await _updateView?.Invoke(EViewAction.ShowHideWindow, false);
});
.Delay(TimeSpan.FromSeconds(1))
.Subscribe(async x =>
{
ShowHideWindow(false);
});
}
}
#endregion UI
#endregion core job
}
}