690 lines
22 KiB
Dart
690 lines
22 KiB
Dart
import 'dart:io';
|
|
|
|
import 'package:fl_clash/common/common.dart';
|
|
import 'package:fl_clash/enum/enum.dart';
|
|
import 'package:fl_clash/models/models.dart';
|
|
import 'package:fl_clash/state.dart';
|
|
import 'package:fl_clash/widgets/widgets.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
class ConfigFragment extends StatefulWidget {
|
|
const ConfigFragment({super.key});
|
|
|
|
@override
|
|
State<ConfigFragment> createState() => _ConfigFragmentState();
|
|
}
|
|
|
|
class _ConfigFragmentState extends State<ConfigFragment> {
|
|
_modifyMixedPort(num mixedPort) async {
|
|
final port = await globalState.showCommonDialog(
|
|
child: MixedPortFormDialog(
|
|
mixedPort: mixedPort,
|
|
),
|
|
);
|
|
if (port != null && port != mixedPort && mounted) {
|
|
try {
|
|
final mixedPort = int.parse(port);
|
|
if (mixedPort < 1024 || mixedPort > 49151) throw "Invalid port";
|
|
globalState.appController.clashConfig.mixedPort = mixedPort;
|
|
} catch (e) {
|
|
globalState.showMessage(
|
|
title: appLocalizations.proxyPort,
|
|
message: TextSpan(
|
|
text: e.toString(),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
_showLogLevelDialog(LogLevel value) {
|
|
globalState.showCommonDialog(
|
|
child: AlertDialog(
|
|
title: Text(appLocalizations.logLevel),
|
|
contentPadding: const EdgeInsets.symmetric(
|
|
horizontal: 8,
|
|
vertical: 16,
|
|
),
|
|
content: SizedBox(
|
|
width: 250,
|
|
child: Wrap(
|
|
children: [
|
|
for (final logLevel in LogLevel.values)
|
|
ListItem.radio(
|
|
delegate: RadioDelegate<LogLevel>(
|
|
value: logLevel,
|
|
groupValue: value,
|
|
onChanged: (LogLevel? value) {
|
|
if (value == null) {
|
|
return;
|
|
}
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.logLevel = value;
|
|
Navigator.of(context).pop();
|
|
},
|
|
),
|
|
title: Text(logLevel.name),
|
|
)
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
_showUaDialog(String? value) {
|
|
const uas = [
|
|
null,
|
|
"clash-verge/v1.6.6",
|
|
"ClashforWindows/0.19.23",
|
|
];
|
|
globalState.showCommonDialog(
|
|
child: AlertDialog(
|
|
title: const Text("UA"),
|
|
contentPadding: const EdgeInsets.symmetric(
|
|
horizontal: 8,
|
|
vertical: 16,
|
|
),
|
|
content: SizedBox(
|
|
width: 250,
|
|
child: Wrap(
|
|
children: [
|
|
for (final ua in uas)
|
|
ListItem.radio(
|
|
delegate: RadioDelegate<String?>(
|
|
value: ua,
|
|
groupValue: value,
|
|
onChanged: (String? value) {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.globalRealUa = value;
|
|
Navigator.of(context).pop();
|
|
},
|
|
),
|
|
title: Text(ua ?? appLocalizations.defaultText),
|
|
)
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
_modifyTestUrl(String testUrl) async {
|
|
final newTestUrl = await globalState.showCommonDialog<String>(
|
|
child: TestUrlFormDialog(
|
|
testUrl: testUrl,
|
|
),
|
|
);
|
|
if (newTestUrl != null && newTestUrl != testUrl && mounted) {
|
|
try {
|
|
if (!newTestUrl.isUrl) {
|
|
throw "Invalid url";
|
|
}
|
|
globalState.appController.config.testUrl = newTestUrl;
|
|
} catch (e) {
|
|
globalState.showMessage(
|
|
title: appLocalizations.testUrl,
|
|
message: TextSpan(
|
|
text: e.toString(),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
_updateKeepAliveInterval(int keepAliveInterval) async {
|
|
final newKeepAliveIntervalString =
|
|
await globalState.showCommonDialog<String>(
|
|
child: KeepAliveIntervalFormDialog(
|
|
keepAliveInterval: keepAliveInterval,
|
|
),
|
|
);
|
|
if (newKeepAliveIntervalString != null &&
|
|
newKeepAliveIntervalString != "$keepAliveInterval" &&
|
|
mounted) {
|
|
try {
|
|
final newKeepAliveInterval = int.parse(newKeepAliveIntervalString);
|
|
if (newKeepAliveInterval <= 0) {
|
|
throw "Invalid keepAliveInterval";
|
|
}
|
|
globalState.appController.clashConfig.keepAliveInterval =
|
|
newKeepAliveInterval;
|
|
globalState.appController.updateClashConfigDebounce();
|
|
} catch (e) {
|
|
globalState.showMessage(
|
|
title: appLocalizations.testUrl,
|
|
message: TextSpan(
|
|
text: e.toString(),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
List<Widget> _buildAppSection() {
|
|
return generateSection(
|
|
title: appLocalizations.app,
|
|
items: [
|
|
if (Platform.isAndroid) ...[
|
|
Selector<Config, bool>(
|
|
selector: (_, config) => config.vpnProps.allowBypass,
|
|
builder: (_, allowBypass, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.arrow_forward_outlined),
|
|
title: Text(appLocalizations.allowBypass),
|
|
subtitle: Text(appLocalizations.allowBypassDesc),
|
|
delegate: SwitchDelegate(
|
|
value: allowBypass,
|
|
onChanged: (bool value) async {
|
|
final config = globalState.appController.config;
|
|
final vpnProps = config.vpnProps;
|
|
config.vpnProps = vpnProps.copyWith(
|
|
allowBypass: value,
|
|
);
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<Config, bool>(
|
|
selector: (_, config) => config.vpnProps.systemProxy,
|
|
builder: (_, systemProxy, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.settings_ethernet),
|
|
title: Text(appLocalizations.systemProxy),
|
|
subtitle: Text(appLocalizations.systemProxyDesc),
|
|
delegate: SwitchDelegate(
|
|
value: systemProxy,
|
|
onChanged: (bool value) async {
|
|
final config = globalState.appController.config;
|
|
final vpnProps = config.vpnProps;
|
|
config.vpnProps = vpnProps.copyWith(
|
|
systemProxy: value,
|
|
);
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
],
|
|
Selector<Config, bool>(
|
|
selector: (_, config) => config.isCloseConnections,
|
|
builder: (_, isCloseConnections, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.auto_delete_outlined),
|
|
title: Text(appLocalizations.autoCloseConnections),
|
|
subtitle: Text(appLocalizations.autoCloseConnectionsDesc),
|
|
delegate: SwitchDelegate(
|
|
value: isCloseConnections,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.config.isCloseConnections = value;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<Config, bool>(
|
|
selector: (_, config) => config.onlyProxy,
|
|
builder: (_, onlyProxy, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.data_usage_outlined),
|
|
title: Text(appLocalizations.onlyStatisticsProxy),
|
|
subtitle: Text(appLocalizations.onlyStatisticsProxyDesc),
|
|
delegate: SwitchDelegate(
|
|
value: onlyProxy,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.config.onlyProxy = value;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
// Selector<Config, bool>(
|
|
// selector: (_, config) => config.isCompatible,
|
|
// builder: (_, isCompatible, __) {
|
|
// return ListItem.switchItem(
|
|
// leading: const Icon(Icons.expand_outlined),
|
|
// title: Text(appLocalizations.compatible),
|
|
// subtitle: Text(appLocalizations.compatibleDesc),
|
|
// delegate: SwitchDelegate(
|
|
// value: isCompatible,
|
|
// onChanged: (bool value) async {
|
|
// final appController = globalState.appController;
|
|
// appController.config.isCompatible = value;
|
|
// await appController.applyProfile();
|
|
// },
|
|
// ),
|
|
// );
|
|
// },
|
|
// ),
|
|
],
|
|
);
|
|
}
|
|
|
|
List<Widget> _buildGeneralSection() {
|
|
return generateSection(
|
|
title: appLocalizations.general,
|
|
items: [
|
|
Selector<ClashConfig, LogLevel>(
|
|
selector: (_, clashConfig) => clashConfig.logLevel,
|
|
builder: (_, value, __) {
|
|
return ListItem(
|
|
leading: const Icon(Icons.info_outline),
|
|
title: Text(appLocalizations.logLevel),
|
|
subtitle: Text(value.name),
|
|
onTap: () {
|
|
_showLogLevelDialog(value);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, String?>(
|
|
selector: (_, clashConfig) => clashConfig.globalRealUa,
|
|
builder: (_, value, __) {
|
|
return ListItem(
|
|
leading: const Icon(Icons.computer_outlined),
|
|
title: const Text("UA"),
|
|
subtitle: Text(value ?? appLocalizations.defaultText),
|
|
onTap: () {
|
|
_showUaDialog(value);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, int>(
|
|
selector: (_, config) => config.keepAliveInterval,
|
|
builder: (_, value, __) {
|
|
return ListItem(
|
|
leading: const Icon(Icons.timer_outlined),
|
|
title: Text(appLocalizations.keepAliveIntervalDesc),
|
|
subtitle: Text("$value ${appLocalizations.seconds}"),
|
|
onTap: () {
|
|
_updateKeepAliveInterval(value);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
Selector<Config, String>(
|
|
selector: (_, config) => config.testUrl,
|
|
builder: (_, value, __) {
|
|
return ListItem(
|
|
leading: const Icon(Icons.timeline),
|
|
title: Text(appLocalizations.testUrl),
|
|
subtitle: Text(value),
|
|
onTap: () {
|
|
_modifyTestUrl(value);
|
|
},
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, int>(
|
|
selector: (_, clashConfig) => clashConfig.mixedPort,
|
|
builder: (_, mixedPort, __) {
|
|
return ListItem(
|
|
onTap: () {
|
|
_modifyMixedPort(mixedPort);
|
|
},
|
|
leading: const Icon(Icons.adjust_outlined),
|
|
title: Text(appLocalizations.proxyPort),
|
|
subtitle: Text(appLocalizations.proxyPortDesc),
|
|
trailing: FilledButton.tonal(
|
|
onPressed: () {
|
|
_modifyMixedPort(mixedPort);
|
|
},
|
|
child: Text(
|
|
"$mixedPort",
|
|
),
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) => clashConfig.ipv6,
|
|
builder: (_, ipv6, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.water_outlined),
|
|
title: const Text("IPv6"),
|
|
subtitle: Text(appLocalizations.ipv6Desc),
|
|
delegate: SwitchDelegate(
|
|
value: ipv6,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.ipv6 = value;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) => clashConfig.allowLan,
|
|
builder: (_, allowLan, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.device_hub),
|
|
title: Text(appLocalizations.allowLan),
|
|
subtitle: Text(appLocalizations.allowLanDesc),
|
|
delegate: SwitchDelegate(
|
|
value: allowLan,
|
|
onChanged: (bool value) async {
|
|
final clashConfig = context.read<ClashConfig>();
|
|
clashConfig.allowLan = value;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) => clashConfig.unifiedDelay,
|
|
builder: (_, unifiedDelay, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.compress_outlined),
|
|
title: Text(appLocalizations.unifiedDelay),
|
|
subtitle: Text(appLocalizations.unifiedDelayDesc),
|
|
delegate: SwitchDelegate(
|
|
value: unifiedDelay,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.unifiedDelay = value;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) =>
|
|
clashConfig.findProcessMode == FindProcessMode.always,
|
|
builder: (_, findProcess, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.polymer_outlined),
|
|
title: Text(appLocalizations.findProcessMode),
|
|
subtitle: Text(appLocalizations.findProcessModeDesc),
|
|
delegate: SwitchDelegate(
|
|
value: findProcess,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.findProcessMode =
|
|
value ? FindProcessMode.always : FindProcessMode.off;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) => clashConfig.tcpConcurrent,
|
|
builder: (_, tcpConcurrent, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.double_arrow_outlined),
|
|
title: Text(appLocalizations.tcpConcurrent),
|
|
subtitle: Text(appLocalizations.tcpConcurrentDesc),
|
|
delegate: SwitchDelegate(
|
|
value: tcpConcurrent,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.tcpConcurrent = value;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) =>
|
|
clashConfig.geodataLoader == geodataLoaderMemconservative,
|
|
builder: (_, memconservative, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.memory),
|
|
title: Text(appLocalizations.geodataLoader),
|
|
subtitle: Text(appLocalizations.geodataLoaderDesc),
|
|
delegate: SwitchDelegate(
|
|
value: memconservative,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.geodataLoader = value
|
|
? geodataLoaderMemconservative
|
|
: geodataLoaderStandard;
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) =>
|
|
clashConfig.externalController.isNotEmpty,
|
|
builder: (_, hasExternalController, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.api_outlined),
|
|
title: Text(appLocalizations.externalController),
|
|
subtitle: Text(appLocalizations.externalControllerDesc),
|
|
delegate: SwitchDelegate(
|
|
value: hasExternalController,
|
|
onChanged: (bool value) async {
|
|
final appController = globalState.appController;
|
|
appController.clashConfig.externalController =
|
|
value ? defaultExternalController : '';
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
List<Widget> _buildMoreSection() {
|
|
return generateSection(
|
|
title: appLocalizations.more,
|
|
items: [
|
|
if (system.isDesktop)
|
|
Selector<ClashConfig, bool>(
|
|
selector: (_, clashConfig) => clashConfig.tun.enable,
|
|
builder: (_, tunEnable, __) {
|
|
return ListItem.switchItem(
|
|
leading: const Icon(Icons.important_devices_outlined),
|
|
title: Text(appLocalizations.tun),
|
|
subtitle: Text(appLocalizations.tunDesc),
|
|
delegate: SwitchDelegate(
|
|
value: tunEnable,
|
|
onChanged: (bool value) async {
|
|
final clashConfig = context.read<ClashConfig>();
|
|
clashConfig.tun = Tun(enable: value);
|
|
},
|
|
),
|
|
);
|
|
},
|
|
),
|
|
],
|
|
);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
List<Widget> items = [
|
|
..._buildAppSection(),
|
|
..._buildGeneralSection(),
|
|
..._buildMoreSection(),
|
|
];
|
|
return ListView.builder(
|
|
padding: const EdgeInsets.only(bottom: 32),
|
|
itemBuilder: (_, index) {
|
|
return Container(
|
|
alignment: Alignment.center,
|
|
child: items[index],
|
|
);
|
|
},
|
|
itemCount: items.length,
|
|
);
|
|
}
|
|
}
|
|
|
|
class MixedPortFormDialog extends StatefulWidget {
|
|
final num mixedPort;
|
|
|
|
const MixedPortFormDialog({super.key, required this.mixedPort});
|
|
|
|
@override
|
|
State<MixedPortFormDialog> createState() => _MixedPortFormDialogState();
|
|
}
|
|
|
|
class _MixedPortFormDialogState extends State<MixedPortFormDialog> {
|
|
late TextEditingController portController;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
portController = TextEditingController(text: "${widget.mixedPort}");
|
|
}
|
|
|
|
_handleUpdate() async {
|
|
final port = portController.value.text;
|
|
if (port.isEmpty) return;
|
|
Navigator.of(context).pop<String>(port);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text(appLocalizations.proxyPort),
|
|
content: SizedBox(
|
|
width: 300,
|
|
child: Wrap(
|
|
runSpacing: 16,
|
|
children: [
|
|
TextField(
|
|
controller: portController,
|
|
decoration: const InputDecoration(
|
|
border: OutlineInputBorder(),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: _handleUpdate,
|
|
child: Text(appLocalizations.submit),
|
|
)
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class TestUrlFormDialog extends StatefulWidget {
|
|
final String testUrl;
|
|
|
|
const TestUrlFormDialog({
|
|
super.key,
|
|
required this.testUrl,
|
|
});
|
|
|
|
@override
|
|
State<TestUrlFormDialog> createState() => _TestUrlFormDialogState();
|
|
}
|
|
|
|
class _TestUrlFormDialogState extends State<TestUrlFormDialog> {
|
|
late TextEditingController testUrlController;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
testUrlController = TextEditingController(text: widget.testUrl);
|
|
}
|
|
|
|
_handleUpdate() async {
|
|
final testUrl = testUrlController.value.text;
|
|
if (testUrl.isEmpty) return;
|
|
Navigator.of(context).pop<String>(testUrl);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text(appLocalizations.testUrl),
|
|
content: SizedBox(
|
|
width: 300,
|
|
child: Wrap(
|
|
runSpacing: 16,
|
|
children: [
|
|
TextField(
|
|
maxLines: 5,
|
|
minLines: 1,
|
|
controller: testUrlController,
|
|
decoration: const InputDecoration(
|
|
border: OutlineInputBorder(),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: _handleUpdate,
|
|
child: Text(appLocalizations.submit),
|
|
)
|
|
],
|
|
);
|
|
}
|
|
}
|
|
|
|
class KeepAliveIntervalFormDialog extends StatefulWidget {
|
|
final int keepAliveInterval;
|
|
|
|
const KeepAliveIntervalFormDialog({
|
|
super.key,
|
|
required this.keepAliveInterval,
|
|
});
|
|
|
|
@override
|
|
State<KeepAliveIntervalFormDialog> createState() =>
|
|
_KeepAliveIntervalFormDialogState();
|
|
}
|
|
|
|
class _KeepAliveIntervalFormDialogState
|
|
extends State<KeepAliveIntervalFormDialog> {
|
|
late TextEditingController keepAliveIntervalController;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
keepAliveIntervalController = TextEditingController(
|
|
text: "${widget.keepAliveInterval}",
|
|
);
|
|
}
|
|
|
|
_handleUpdate() async {
|
|
final keepAliveInterval = keepAliveIntervalController.value.text;
|
|
if (keepAliveInterval.isEmpty) return;
|
|
Navigator.of(context).pop<String>(keepAliveInterval);
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return AlertDialog(
|
|
title: Text(appLocalizations.keepAliveIntervalDesc),
|
|
content: SizedBox(
|
|
width: 300,
|
|
child: Wrap(
|
|
runSpacing: 16,
|
|
children: [
|
|
TextField(
|
|
maxLines: 1,
|
|
minLines: 1,
|
|
controller: keepAliveIntervalController,
|
|
decoration: InputDecoration(
|
|
border: const OutlineInputBorder(),
|
|
suffixText: appLocalizations.seconds,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
actions: [
|
|
TextButton(
|
|
onPressed: _handleUpdate,
|
|
child: Text(appLocalizations.submit),
|
|
)
|
|
],
|
|
);
|
|
}
|
|
}
|