feat: new ui (#1455)

This commit is contained in:
Levi authored and GitHub committed 2026-09-05 19:53:41 +08:00
1 parent 3be8db664c
commit 177c225f16
742 files changed
+59951 -5934

No files matched your search

+137
View File
@@ -0,0 +1,137 @@
import 'dart:io';
import 'package:device_info_plus/device_info_plus.dart';
import 'package:dio/dio.dart';
import 'package:flutter/foundation.dart';
import 'package:gopeed/database/database.dart';
import 'package:gopeed/util/package_info.dart';
import 'log_util.dart';
/// GA4 Measurement Protocol configuration from dart-define
class Config {
static const String measurementId =
String.fromEnvironment('GA4_MEASUREMENT_ID');
static const String apiSecret = String.fromEnvironment('GA4_API_SECRET');
static bool get isConfigured =>
measurementId.isNotEmpty && apiSecret.isNotEmpty;
}
/// GA4 Measurement Protocol Analytics
class Analytics {
static final Analytics _instance = Analytics._internal();
static Analytics get instance => _instance;
Analytics._internal();
late String _clientId;
late int _sessionId;
late Dio _dio;
bool _initialized = false;
Future<void> init() async {
if (_initialized) return;
if (!Config.isConfigured) return;
_clientId = await _getDeviceId();
_dio = Dio(BaseOptions(
connectTimeout: const Duration(seconds: 10),
receiveTimeout: const Duration(seconds: 10),
));
_sessionId = DateTime.now().millisecondsSinceEpoch ~/ 1000;
_initialized = true;
}
Future<String> _getDeviceId() async {
final deviceInfo = DeviceInfoPlugin();
String? deviceId;
try {
if (kIsWeb) {
deviceId = null;
} else if (Platform.isAndroid) {
final androidInfo = await deviceInfo.androidInfo;
deviceId = androidInfo.id;
} else if (Platform.isIOS) {
final iosInfo = await deviceInfo.iosInfo;
deviceId = iosInfo.identifierForVendor;
} else if (Platform.isMacOS) {
final macInfo = await deviceInfo.macOsInfo;
deviceId = macInfo.systemGUID;
} else if (Platform.isWindows) {
final windowsInfo = await deviceInfo.windowsInfo;
deviceId = windowsInfo.deviceId;
} else if (Platform.isLinux) {
final linuxInfo = await deviceInfo.linuxInfo;
deviceId = linuxInfo.machineId;
}
} catch (e) {
debugPrint('GA4Analytics: Failed to get device id: $e');
}
// Fallback to persisted client id
if (deviceId == null || deviceId.isEmpty) {
deviceId = Database.instance.getAnalyticsClientId();
if (deviceId == null || deviceId.isEmpty) {
final random = DateTime.now().microsecondsSinceEpoch % 2147483647;
final timestamp = DateTime.now().millisecondsSinceEpoch ~/ 1000;
deviceId = '$random.$timestamp';
Database.instance.saveAnalyticsClientId(deviceId);
}
}
return deviceId;
}
String _getPlatform() {
if (kIsWeb) return 'web';
if (Platform.isAndroid) return 'android';
if (Platform.isIOS) return 'ios';
if (Platform.isMacOS) return 'macos';
if (Platform.isWindows) return 'windows';
if (Platform.isLinux) return 'linux';
return 'unknown';
}
Future<void> logAppOpen() async {
await logEvent('app_open');
}
Future<void> logEvent(String name, [Map<String, dynamic>? params]) async {
if (!_initialized) {
return;
}
final eventParams = <String, dynamic>{
'session_id': _sessionId.toString(),
'engagement_time_msec': 100,
'platform': _getPlatform(),
'app_version': packageInfo.version,
...?params,
};
final payload = {
'client_id': _clientId,
'timestamp_micros': DateTime.now().microsecondsSinceEpoch,
'events': [
{
'name': name,
'params': eventParams,
}
],
};
try {
await _dio.post(
'https://www.google-analytics.com/mp/collect',
queryParameters: {
'measurement_id': Config.measurementId,
'api_secret': Config.apiSecret,
},
data: payload,
);
} catch (e) {
logger.w('GA4Analytics: Failed to send event "$name": $e');
}
}
}
+15
View File
@@ -0,0 +1,15 @@
import 'arch_stub.dart'
if (dart.library.io) 'entry/arch_native.dart'
if (dart.library.html) 'entry/arch_web.dart';
// Copy from pkg/sky_engine/lib/ffi/abi.dart
enum Architecture {
arm,
arm64,
ia32,
x64,
riscv32,
riscv64,
}
Architecture getArch() => doGetArch();
@@ -0,0 +1,3 @@
import 'arch.dart';
Architecture doGetArch() => throw UnimplementedError();
@@ -0,0 +1,13 @@
// ignore: avoid_web_libraries_in_flutter
import 'dart:ffi';
import '../arch.dart';
Architecture doGetArch() {
final currentAbi = Abi.current().toString();
final archName = currentAbi.split("_")[1];
final arch = Architecture.values.firstWhere(
(element) => element.name == archName,
orElse: () => Architecture.x64);
return arch;
}
@@ -0,0 +1,5 @@
import '../arch.dart';
Architecture doGetArch() {
return Architecture.x64;
}
@@ -0,0 +1,4 @@
import 'browser_download_stub.dart'
if (dart.library.html) 'entry/browser_download_browser.dart';
void download(String url, String name) => doDownload(url, name);
@@ -0,0 +1 @@
void doDownload(String url, String name) => throw UnimplementedError();
@@ -0,0 +1,9 @@
// ignore: avoid_web_libraries_in_flutter
import 'dart:html' as html;
void doDownload(String url, String name) {
final anchorElement = html.AnchorElement(href: url);
anchorElement.download = name;
anchorElement.target = '_blank';
anchorElement.click();
}
@@ -0,0 +1,18 @@
import 'browser_extension_host_stub.dart'
if (dart.library.io) 'entry/browser_extension_host_native.dart';
enum Browser { chrome, edge, firefox }
/// Install host binary for browser extension
Future<void> installHost() => doInstallHost();
/// Check if specified browser is installed
Future<bool> checkBrowserInstalled(Browser browser) =>
doCheckBrowserInstalled(browser);
/// Check if browser extension manifest is properly installed
Future<bool> checkManifestInstalled(Browser browser) =>
doCheckManifestInstalled(browser);
/// Install browser extension manifest
Future<void> installManifest(Browser browser) => doInstallManifest(browser);
@@ -0,0 +1,8 @@
import 'browser_extension_host.dart';
Future<void> doInstallHost() => throw UnimplementedError();
Future<bool> doCheckBrowserInstalled(Browser browser) =>
throw UnimplementedError();
Future<bool> doCheckManifestInstalled(Browser browser) =>
throw UnimplementedError();
Future<void> doInstallManifest(Browser browser) => throw UnimplementedError();
@@ -0,0 +1,304 @@
import 'dart:convert';
import 'dart:io';
import 'package:path/path.dart' as path;
import 'package:win32_registry/win32_registry.dart';
import '../../util.dart';
import '../../win32.dart';
import '../browser_extension_host.dart';
final _hostExecName = 'host${Platform.isWindows ? '.exe' : ''}';
const _hostName = 'com.gopeed.gopeed';
const _chromeExtensionId = 'mijpgljlfcapndmchhjffkpckknofcnd';
const _edgeExtensionId = 'dkajnckekendchdleoaenoophcobooce';
const _firefoxExtensionId = '{c5d69a8f-2ed0-46a7-afa4-b3a00dc58088}';
List<String> get _debugExtensionIds {
final envValue = Platform.environment['GOPEED_DEBUG_EXTENSION_IDS'] ?? '';
if (envValue.isNotEmpty) {
return envValue.split(',').map((id) => id.trim()).toList();
}
return [];
}
// Windows NativeMessagingHosts registry constants
const _chromeNativeHostsKey = r'Software\Google\Chrome\NativeMessagingHosts';
const _edgeNativeHostsKey = r'Software\Microsoft\Edge\NativeMessagingHosts';
const _firefoxNativeHostsKey = r'Software\Mozilla\NativeMessagingHosts';
/// Install host binary for browser extension
Future<void> doInstallHost() async {
final hostPath = await Util.homePathJoin(_hostExecName);
await Util.installAsset('assets/exec/$_hostExecName', hostPath,
executable: true);
}
/// Check if specified browser is installed
Future<bool> doCheckBrowserInstalled(Browser browser) async {
if (Platform.isWindows) {
switch (browser) {
case Browser.chrome:
return await _checkWindowsRegistry(
r'SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe') ||
await _checkWindowsRegistry(
r'SOFTWARE\WOW6432Node\Google\Chrome') ||
await _checkWindowsExecutable(browser);
case Browser.edge:
return await _checkWindowsRegistry(
r'SOFTWARE\Microsoft\Edge\BLBeacon') ||
await _checkWindowsRegistry(
r'SOFTWARE\WOW6432Node\Microsoft\Edge\BLBeacon') ||
await _checkWindowsExecutable(browser);
case Browser.firefox:
return await _checkWindowsRegistry(r'SOFTWARE\Mozilla\Firefox') ||
await _checkWindowsRegistry(
r'SOFTWARE\WOW6432Node\Mozilla\Firefox') ||
await _checkWindowsRegistry(r'SOFTWARE\BrowserWorks\Waterfox') ||
await _checkWindowsExecutable(browser);
}
} else {
return await _checkUnixExecutable(browser);
}
}
/// Check if browser extension manifest is properly installed
Future<bool> doCheckManifestInstalled(Browser browser) async {
if (await checkBrowserInstalled(browser) == false) return false;
final manifestPath = await _getManifestPath(browser);
if (manifestPath == null) return false;
if (Platform.isWindows) {
final regKey = _getWindowsRegistryKey(browser);
if (!checkRegistry('$regKey\\$_hostName', '', manifestPath)) {
return false;
}
}
if (!await File(manifestPath).exists()) {
return false;
}
final existingContent = await File(manifestPath).readAsString();
final expectedContent = await _getManifestContent(browser);
return existingContent == expectedContent;
}
/// Install browser extension manifest
Future<void> doInstallManifest(Browser browser) async {
if (await checkBrowserInstalled(browser) == false) return;
if (await checkManifestInstalled(browser)) return;
final manifestPath = (await _getManifestPath(browser))!;
final manifestContent = await _getManifestContent(browser);
final manifestDir = path.dirname(manifestPath);
await Directory(manifestDir).create(recursive: true);
await File(manifestPath).writeAsString(manifestContent);
if (Platform.isWindows) {
final regKey = _getWindowsRegistryKey(browser);
upsertRegistry('$regKey\\$_hostName', '', manifestPath);
}
}
Future<bool> _checkWindowsExecutable(Browser browser) async {
final paths = _getWindowsExecutablePaths(browser);
for (var execPath in paths) {
if (await File(execPath).exists()) {
return true;
}
}
return false;
}
List<String> _getWindowsExecutablePaths(Browser browser) {
final programFiles = Platform.environment['PROGRAMFILES'];
final programFilesX86 = Platform.environment['PROGRAMFILES(X86)'];
final localAppData = Platform.environment['LOCALAPPDATA'];
switch (browser) {
case Browser.chrome:
return [
if (programFiles != null)
path.join(
programFiles, 'Google', 'Chrome', 'Application', 'chrome.exe'),
if (programFilesX86 != null)
path.join(
programFilesX86, 'Google', 'Chrome', 'Application', 'chrome.exe'),
if (localAppData != null)
path.join(
localAppData, 'Google', 'Chrome', 'Application', 'chrome.exe'),
];
case Browser.edge:
return [
if (programFiles != null)
path.join(
programFiles, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
if (programFilesX86 != null)
path.join(programFilesX86, 'Microsoft', 'Edge', 'Application',
'msedge.exe'),
if (localAppData != null)
path.join(
localAppData, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
];
case Browser.firefox:
return [
if (programFiles != null)
path.join(programFiles, 'Mozilla Firefox', 'firefox.exe'),
if (programFilesX86 != null)
path.join(programFilesX86, 'Mozilla Firefox', 'firefox.exe'),
if (programFiles != null)
path.join(programFiles, 'Waterfox', 'waterfox.exe'),
if (programFilesX86 != null)
path.join(programFilesX86, 'Waterfox', 'waterfox.exe'),
];
}
}
Future<bool> _checkUnixExecutable(Browser browser) async {
final paths = _getUnixExecutablePaths(browser);
for (var execPath in paths) {
execPath = execPath.replaceAll('~', Platform.environment['HOME'] ?? '');
if (await Directory(execPath).exists() || await File(execPath).exists()) {
return true;
}
}
return false;
}
List<String> _getUnixExecutablePaths(Browser browser) {
if (Platform.isMacOS) {
switch (browser) {
case Browser.chrome:
return [
'/Applications/Google Chrome.app',
'~/Applications/Google Chrome.app',
'/Users/${Platform.environment['USER']}/Applications/Google Chrome.app'
];
case Browser.edge:
return [
'/Applications/Microsoft Edge.app',
'~/Applications/Microsoft Edge.app',
'/Users/${Platform.environment['USER']}/Applications/Microsoft Edge.app'
];
case Browser.firefox:
return [
'/Applications/Firefox.app',
'~/Applications/Firefox.app',
'/Users/${Platform.environment['USER']}/Applications/Firefox.app',
'/Applications/Waterfox.app',
'~/Applications/Waterfox.app',
'/Users/${Platform.environment['USER']}/Applications/Waterfox.app'
];
}
} else {
switch (browser) {
case Browser.chrome:
return [
'/usr/bin/google-chrome',
'/usr/bin/google-chrome-stable',
'/usr/bin/chrome',
'/snap/bin/google-chrome',
'/opt/google/chrome/google-chrome'
];
case Browser.edge:
return [
'/usr/bin/microsoft-edge',
'/usr/bin/microsoft-edge-stable',
'/snap/bin/microsoft-edge',
'/opt/microsoft/msedge/msedge'
];
case Browser.firefox:
return [
'/usr/bin/firefox',
'/snap/bin/firefox',
'/usr/lib/firefox/firefox',
'/opt/firefox/firefox',
'/usr/bin/waterfox',
'/snap/bin/waterfox',
'/usr/lib/waterfox/waterfox',
'/opt/waterfox/waterfox'
];
}
}
}
Future<String?> _getManifestPath(Browser browser) async {
final manifestName =
browser == Browser.firefox ? '$_hostName.moz.json' : '$_hostName.json';
if (Platform.isWindows) {
return await Util.homePathJoin(manifestName);
}
final home =
Platform.environment['HOME'] ?? Platform.environment['USERPROFILE'];
if (home == null) return null;
if (Platform.isMacOS) {
switch (browser) {
case Browser.chrome:
return path.join(home, 'Library', 'Application Support', 'Google',
'Chrome', 'NativeMessagingHosts', manifestName);
case Browser.edge:
return path.join(home, 'Library', 'Application Support',
'Microsoft Edge', 'NativeMessagingHosts', manifestName);
case Browser.firefox:
return path.join(home, 'Library', 'Application Support', 'Mozilla',
'NativeMessagingHosts', manifestName);
}
} else if (Platform.isLinux) {
switch (browser) {
case Browser.chrome:
return path.join(home, '.config', 'google-chrome',
'NativeMessagingHosts', manifestName);
case Browser.edge:
return path.join(home, '.config', 'microsoft-edge',
'NativeMessagingHosts', manifestName);
case Browser.firefox:
return path.join(
home, '.mozilla', 'native-messaging-hosts', manifestName);
}
}
return null;
}
Future<bool> _checkWindowsRegistry(String keyPath) async {
try {
final key = Registry.openPath(RegistryHive.localMachine, path: keyPath);
key.close();
return true;
} catch (e) {
return false;
}
}
Future<String> _getManifestContent(Browser browser) async {
final hostPath = await Util.homePathJoin(_hostExecName);
final manifest = {
'name': _hostName,
'description': 'Gopeed browser extension host',
'path': hostPath,
'type': 'stdio',
if (browser != Browser.firefox)
'allowed_origins': [
'chrome-extension://$_chromeExtensionId/',
'chrome-extension://$_edgeExtensionId/',
..._debugExtensionIds.map((id) => 'chrome-extension://$id/'),
],
if (browser == Browser.firefox) 'allowed_extensions': [_firefoxExtensionId],
};
return const JsonEncoder.withIndent(' ').convert(manifest);
}
String _getWindowsRegistryKey(Browser browser) {
switch (browser) {
case Browser.chrome:
return _chromeNativeHostsKey;
case Browser.edge:
return _edgeNativeHostsKey;
case Browser.firefox:
return _firefoxNativeHostsKey;
}
}
+76
View File
@@ -0,0 +1,76 @@
import 'dart:core';
import 'package:checkable_treeview/checkable_treeview.dart';
import 'package:flutter/material.dart';
import '../api/model/resource.dart';
import '../app/views/file_icon.dart';
import 'util.dart';
extension ListFileInfoExtension on List<FileInfo> {
List<TreeNode<int>> toTreeNodes() {
final List<TreeNode<int>> rootNodes = [];
final Map<String, TreeNode<int>> dirNodes = {};
var nodeIndex = 0;
for (var i = 0; i < length; i++) {
final file = this[i];
final parts = file.path.split('/');
String currentPath = '';
TreeNode<int>? parentNode;
// Create or get directory nodes
for (final part in parts) {
if (part.isEmpty) continue;
currentPath += '/$part';
if (!dirNodes.containsKey(currentPath)) {
final node = TreeNode<int>(
value: nodeIndex++,
label: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Text(file.name),
Text(Util.fmtByte(file.size)),
],
),
icon: Icon(
fileIcon(part, isFolder: true),
size: 18,
),
children: [],
);
dirNodes[currentPath] = node;
if (parentNode == null) {
rootNodes.add(node);
} else {
parentNode.children.add(node);
}
}
parentNode = dirNodes[currentPath];
}
// Create file node using file.name
final fileNode = TreeNode<int>(
value: nodeIndex++,
label: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Text(file.name),
Text(Util.fmtByte(file.size)),
],
),
icon: Icon(fileIcon(file.name, isFolder: false), size: 18),
children: [],
);
// Add file node to parent or root
if (parentNode != null) {
parentNode.children.add(fileNode);
} else {
rootNodes.add(fileNode);
}
}
return rootNodes;
}
}
@@ -0,0 +1,37 @@
import 'dart:io';
import 'package:open_dir/open_dir.dart';
import 'package:path/path.dart' as path;
import 'package:url_launcher/url_launcher_string.dart';
class FileExplorer {
static Future<void> openAndSelectFile(String filePath) async {
if (await FileSystemEntity.isFile(filePath)) {
_openFile(filePath);
} else if (await FileSystemEntity.isDirectory(filePath)) {
await _openDirectory(filePath);
} else {
// If file does not exist, open its parent directory
final parentPath = path.dirname(filePath);
if (await FileSystemEntity.isDirectory(parentPath)) {
await _openDirectory(parentPath);
}
}
}
static Future<void> _openDirectory(String directoryPath) async {
if (Platform.isWindows || Platform.isMacOS || Platform.isLinux) {
await OpenDir().openNativeDir(path: directoryPath);
} else {
await launchUrlString("file://$directoryPath");
}
}
static Future<void> _openFile(String filePath) async {
if (Platform.isWindows || Platform.isMacOS || Platform.isLinux) {
final fileName = path.basename(filePath);
final parentPath = path.dirname(filePath);
await OpenDir()
.openNativeDir(path: parentPath, highlightedFileName: fileName);
}
}
}
+104
View File
@@ -0,0 +1,104 @@
import 'package:dio/dio.dart';
import 'package:get/get.dart';
import '../api/model/downloader_config.dart';
import '../app/modules/app/controllers/app_controller.dart';
enum MirrorType {
githubSource,
githubRelease,
}
/// Get the configured mirrors
List<GithubMirror> _getConfiguredMirrors() {
try {
final appController = Get.find<AppController>();
final config = appController.downloaderConfig.value.extra.githubMirror;
if (!config.enabled) {
return [];
}
// Return configured mirrors (filtering not deleted ones)
return config.mirrors.where((m) => !m.isDeleted).toList();
} catch (e) {
// Fallback to empty list if controller not found
return [];
}
}
/// Auto detect the best mirror for the given [rawUrl] and [type]
Future<String> githubAutoMirror(String rawUrl, MirrorType type) async {
final mirrorUrls = githubMirrorUrls(rawUrl, type);
// If no mirrors, return original URL
if (mirrorUrls.isEmpty) {
return rawUrl;
}
// Ping all mirrors and get the fastest one
final pingResult = await Future.wait(mirrorUrls.map((e) async {
final client = Dio()
..options.sendTimeout = const Duration(seconds: 3)
..options.connectTimeout = const Duration(seconds: 3);
var time = DateTime.now().millisecondsSinceEpoch;
try {
final response = await client.head(e);
if (response.statusCode == 200) {
time = DateTime.now().millisecondsSinceEpoch - time;
return (e, time);
}
} catch (e) {
// ignore
} finally {
client.close();
}
return (e, -1);
}));
var list = pingResult.where((e) => e.$2 != -1).toList()
..sort((a, b) => a.$2.compareTo(b.$2));
if (list.isNotEmpty) {
return list.first.$1;
}
return rawUrl;
}
List<String> githubMirrorUrls(String rawUrl, MirrorType type) {
final mirrors = _getConfiguredMirrors();
final ret = <String>[];
for (final mirror in mirrors) {
String? mirrorUrl;
if (mirror.type == GithubMirrorType.jsdelivr) {
// jsdelivr only supports source files
if (type != MirrorType.githubSource) {
continue;
}
// Transform: https://raw.githubusercontent.com/user/repo/master/path
// To: https://fastly.jsdelivr.net/gh/user/repo/path
final jsDelivrPattern = RegExp(
r'.*raw\.githubusercontent\.com(/[^/]+)(/[^/]+)/(?:master|main)(/.*)');
final match = jsDelivrPattern.firstMatch(rawUrl);
if (match != null) {
final user = match.group(1);
final repo = match.group(2);
final path = match.group(3);
mirrorUrl = '${mirror.url}$user$repo$path';
}
} else if (mirror.type == GithubMirrorType.ghProxy) {
// gh-proxy supports both source and release
// Simply prepend the mirror URL to the original URL
mirrorUrl = '${mirror.url}/$rawUrl';
}
if (mirrorUrl != null) {
ret.add(mirrorUrl);
}
}
return ret;
}
@@ -0,0 +1,30 @@
import 'package:flutter/services.dart';
/// A [TextInputFormatter] that restricts input to a numerical range between [min] and [max].
class NumericalRangeFormatter extends TextInputFormatter {
final int min;
final int max;
NumericalRangeFormatter({required this.min, required this.max});
@override
TextEditingValue formatEditUpdate(
TextEditingValue oldValue,
TextEditingValue newValue,
) {
if (newValue.text.isEmpty) {
return newValue;
}
var intVal = int.tryParse(newValue.text);
if (intVal == null) {
return oldValue;
}
if (intVal < min) {
return newValue.copyWith(text: min.toString());
} else if (intVal > max) {
return oldValue.copyWith(text: max.toString());
} else {
return newValue;
}
}
}
@@ -0,0 +1,13 @@
import 'package:flutter/material.dart';
Locale toLocale(String key) {
final arr = key.split('_');
return Locale(arr[0], arr[1]);
}
String getLocaleKey(Locale locale) {
return '${locale.languageCode}_${locale.countryCode}';
}
const debugLocale = Locale('zh', 'CN');
const fallbackLocale = Locale('en', 'US');
+33
View File
@@ -0,0 +1,33 @@
import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:logger/logger.dart';
import 'package:path/path.dart' as path;
import 'util.dart';
late final Logger logger;
initLogger() {
// if is debug mode, don't log to file
logger = Logger(
filter: ProductionFilter(),
printer: SimplePrinter(printTime: true, colors: false),
output: _buildOutput(),
);
}
String logsDir() {
return path.join(Util.getStorageDir(), 'logs');
}
_buildOutput() {
// if is debug mode, don't log to file
if (!kDebugMode && Util.isDesktop()) {
final logDirPath = logsDir();
var logDir = Directory(logsDir());
if (!logDir.existsSync()) {
logDir.createSync();
}
return FileOutput(file: File('$logDirPath/client.log'));
}
return null;
}
+35
View File
@@ -0,0 +1,35 @@
import 'package:get/get.dart';
import '../api/model/result.dart';
void showErrorMessage(msg) {
final title = 'error'.tr;
if (msg is Result) {
Get.snackbar(title, msg.msg!);
return;
}
if (msg is Exception) {
final message = (msg as dynamic).message;
if (message is Result) {
Get.snackbar(title, ((msg as dynamic).message as Result).msg!);
return;
}
if (message is String) {
Get.snackbar(title, message);
return;
}
}
Get.snackbar(title, msg.toString());
}
var _showMessageFlag = true;
void showMessage(title, msg) {
if (_showMessageFlag) {
_showMessageFlag = false;
Get.snackbar(title, msg);
Future.delayed(const Duration(seconds: 3), () {
_showMessageFlag = true;
});
}
}
@@ -0,0 +1,7 @@
import 'package:package_info_plus/package_info_plus.dart';
late PackageInfo packageInfo;
Future<void> initPackageInfo() async {
packageInfo = await PackageInfo.fromPlatform();
}
@@ -0,0 +1,77 @@
import 'dart:io';
import 'package:win32_registry/win32_registry.dart';
import '../../util.dart';
import '../../win32.dart';
doRegisterUrlScheme(String scheme) {
if (Util.isWindows()) {
final schemeKey = 'Software\\Classes\\$scheme';
final appPath = Platform.resolvedExecutable;
upsertRegistry(
schemeKey,
'URL Protocol',
'',
);
upsertRegistry(
'$schemeKey\\shell\\open\\command',
'',
'"$appPath" "%1"',
);
}
}
doUnregisterUrlScheme(String scheme) {
if (Util.isWindows()) {
Registry.currentUser
.deleteKey('Software\\Classes\\$scheme', recursive: true);
}
}
const _torrentRegKey = 'Software\\Classes\\.torrent';
const _torrentRegValue = 'Gopeed_torrent';
const _torrentAppRegKey = 'Software\\Classes\\$_torrentRegValue';
/// Register as the system's default torrent client
/// 1. Register the scheme "magnet"
/// 2. Register the file type ".torrent"
doRegisterDefaultTorrentClient() {
if (Util.isWindows()) {
doRegisterUrlScheme("magnet");
final appPath = Platform.resolvedExecutable;
final iconPath =
'${File(appPath).parent.path}\\data\\flutter_assets\\assets\\tray_icon\\icon.ico';
upsertRegistry(
_torrentRegKey,
'',
_torrentRegValue,
);
upsertRegistry(
_torrentAppRegKey,
'',
'Torrent file',
);
upsertRegistry(
'$_torrentAppRegKey\\DefaultIcon',
'',
iconPath,
);
upsertRegistry(
'$_torrentAppRegKey\\shell\\open\\command',
'',
'"$appPath" "file:///%1"',
);
}
}
doUnregisterDefaultTorrentClient() {
if (Util.isWindows()) {
doUnregisterUrlScheme("magnet");
Registry.currentUser.deleteKey(_torrentRegKey, recursive: true);
Registry.currentUser.deleteKey(_torrentAppRegKey, recursive: true);
}
}
@@ -0,0 +1,10 @@
import 'scheme_register_stub.dart'
if (dart.library.io) 'entry/scheme_register_native.dart';
registerUrlScheme(String scheme) => doRegisterUrlScheme(scheme);
unregisterUrlScheme(String scheme) => doUnregisterUrlScheme(scheme);
registerDefaultTorrentClient() => doRegisterDefaultTorrentClient();
unregisterDefaultTorrentClient() => doUnregisterDefaultTorrentClient();
@@ -0,0 +1,7 @@
doRegisterUrlScheme(String scheme) => throw UnimplementedError();
doUnregisterUrlScheme(String scheme) => throw UnimplementedError();
doRegisterDefaultTorrentClient() => throw UnimplementedError();
doUnregisterDefaultTorrentClient() => throw UnimplementedError();
+436
View File
@@ -0,0 +1,436 @@
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:install_plugin/install_plugin.dart';
import 'package:path/path.dart' as path;
import 'package:path_provider/path_provider.dart';
import 'package:url_launcher/url_launcher.dart';
import '../api/api.dart';
import '../api/gopeed_site_api.dart';
import '../app/views/outlined_button_loading.dart';
import 'arch/arch.dart';
import 'github_mirror.dart';
import 'log_util.dart';
import 'message.dart';
import 'package_info.dart';
import 'util.dart';
enum Channel {
windowsInstaller,
windowsPortable,
macosDmg,
linuxFlathub,
linuxSnap,
linuxDeb,
linuxAppImage,
androidApk,
iosIpa,
docker,
}
const _channelEnv = String.fromEnvironment("UPDATE_CHANNEL");
final _channel =
Channel.values.where((e) => e.name == _channelEnv).firstOrNull ??
() {
if (Util.isWindows()) {
return Channel.windowsPortable;
} else if (Util.isMacos()) {
return Channel.macosDmg;
} else if (Util.isAndroid()) {
return Channel.androidApk;
} else if (Util.isIOS()) {
return Channel.iosIpa;
} else {
return null;
}
}();
final _updaterBin = "updater${Util.isWindows() ? ".exe" : ""}";
Future<void> installUpdater() async {
await Util.installAsset(
'assets/exec/$_updaterBin', await Util.homePathJoin(_updaterBin),
executable: true);
}
class VersionInfo {
final String version;
final String changeLog;
VersionInfo(this.version, this.changeLog);
}
Future<VersionInfo?> checkUpdate() async {
String? releaseDataStr;
try {
releaseDataStr = (await proxyRequest(
"https://api.github.com/repos/GopeedLab/gopeed/releases/latest"))
.data;
} catch (e) {
releaseDataStr = jsonEncode(await GopeedSiteApi.instance.getRelease());
}
if (releaseDataStr == null) {
return null;
}
final releaseData = jsonDecode(releaseDataStr);
final tagName = releaseData["tag_name"];
if (tagName == null) {
return null;
}
final latestVersion = releaseData["tag_name"].substring(1);
// compare version x.y.z to x.y.z
final currentVersion = packageInfo.version;
var isNewVersion = false;
if (latestVersion != currentVersion) {
final currentVersionList = currentVersion.split(".");
final latestVersionList = latestVersion.split(".");
for (var i = 0; i < currentVersionList.length; i++) {
if (int.parse(latestVersionList[i]) > int.parse(currentVersionList[i])) {
isNewVersion = true;
break;
}
}
}
if (!isNewVersion) {
return null;
}
return VersionInfo(latestVersion, releaseData["body"]);
}
Future<void> showUpdateDialog(
BuildContext context, VersionInfo versionInfo) async {
final fullChangeLog = versionInfo.changeLog;
final isZh = Get.locale?.languageCode == "zh";
final changeLogRegex = isZh
? RegExp(r"(#\s+更新日志.*)", multiLine: true, dotAll: true)
: RegExp(r"(# Release notes.*)#\s+更新日志", multiLine: true, dotAll: true);
final changeLog = changeLogRegex.firstMatch(fullChangeLog)?.group(1) ?? "";
await showDialog(
context: Get.context!,
barrierDismissible: false,
builder: (context) {
bool isDownloading = false;
double progress = 0;
int total = 0;
final buttonController = OutlinedButtonLoadingController();
return StatefulBuilder(
builder: (context, setState) {
final screenSize = MediaQuery.of(context).size;
final dialogWidth =
screenSize.width < 500 ? screenSize.width * 0.9 : 500.0;
final dialogHeight =
screenSize.height < 600 ? screenSize.height * 0.8 : 400.0;
return Dialog(
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(16),
),
child: SizedBox(
width: dialogWidth,
child: Padding(
padding: const EdgeInsets.all(20),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'newVersionTitle'
.trParams({'version': versionInfo.version}),
style: const TextStyle(
fontSize: 20,
fontWeight: FontWeight.bold,
),
),
const SizedBox(height: 16),
Container(
height: dialogHeight * 0.5,
decoration: BoxDecoration(
border:
Border.all(color: Theme.of(context).dividerColor),
borderRadius: BorderRadius.circular(8),
),
child: ScrollConfiguration(
behavior: ScrollConfiguration.of(context).copyWith(
scrollbars: true,
),
child: Builder(
builder: (context) {
final controller = ScrollController();
return Scrollbar(
controller: controller,
thumbVisibility: true,
child: SingleChildScrollView(
controller: controller,
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment:
CrossAxisAlignment.start,
children:
_parseMarkdown(changeLog, context),
),
),
),
);
},
),
),
),
if (isDownloading) ...[
const SizedBox(height: 16),
LinearProgressIndicator(
value: progress,
valueColor: AlwaysStoppedAnimation<Color>(
Theme.of(context).colorScheme.primary,
),
),
const SizedBox(height: 4),
Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Text(
'${(progress * 100).toStringAsFixed(1)}%',
style: const TextStyle(fontSize: 12),
),
Text(
total == 0
? ''
: '${Util.fmtByte((total * progress).toInt())} / ${Util.fmtByte(total)}',
style: const TextStyle(fontSize: 12),
),
],
)
],
const SizedBox(height: 20),
Row(
mainAxisAlignment: MainAxisAlignment.end,
children: [
TextButton(
onPressed: isDownloading ? null : () => Get.back(),
child: Text(
'newVersionLater'.tr,
style: TextStyle(
color: isDownloading
? Theme.of(context).disabledColor
: Theme.of(context).colorScheme.error),
),
),
const SizedBox(width: 8),
OutlinedButtonLoading(
controller: buttonController,
onPressed: () async {
setState(() {
isDownloading = true;
});
buttonController.start();
try {
await _update(versionInfo.version,
(received, fileTotal) {
setState(() {
total = fileTotal;
progress = received / fileTotal;
});
});
} catch (e) {
showErrorMessage(e);
} finally {
setState(() {
isDownloading = false;
});
buttonController.stop();
}
},
child: Text('newVersionUpdate'.tr),
),
],
),
],
),
),
),
);
},
);
},
);
}
List<Widget> _parseMarkdown(String markdown, BuildContext context) {
final List<Widget> widgets = [];
final lines = markdown.split('\n');
for (final line in lines) {
if (line.trim().isEmpty) continue;
if (line.startsWith('# ')) {
// H1 header
widgets.add(Text(
line.substring(2),
style: const TextStyle(
fontSize: 18,
fontWeight: FontWeight.bold,
),
));
} else if (line.startsWith('## ')) {
// H2 header
widgets.add(Text(
line.substring(3),
style: const TextStyle(
fontSize: 16,
fontWeight: FontWeight.bold,
),
));
} else if (line.trim().startsWith('- ')) {
// List item
widgets.add(Padding(
padding: const EdgeInsets.only(left: 8),
child: Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
const Text('• ', style: TextStyle(fontSize: 14)),
Expanded(
child: Text(
line.substring(line.indexOf('-') + 1).trim().replaceFirst(
RegExp(r'@[^\s]*\s\(#\d+\)'),
''), // Remove contributor and pr number
style: const TextStyle(fontSize: 14),
),
),
],
),
));
} else {
// Normal text
widgets.add(Text(
line,
style: const TextStyle(fontSize: 14),
));
}
// Add spacing between elements
widgets.add(const SizedBox(height: 8));
}
return widgets;
}
Future<void> _update(String version, Function(int, int) onProgress) async {
var newVersionAssetPath = "";
final newVersionAssetName = _getAssetName(version);
// Need to download the asset
if (newVersionAssetName.isNotEmpty) {
final downloadUrl =
'https://github.com/GopeedLab/gopeed/releases/download/v$version/$newVersionAssetName';
newVersionAssetPath = await _getAssetPath(version);
if (downloadUrl.isNotEmpty) {
final fastDownloadUrl =
await githubAutoMirror(downloadUrl, MirrorType.githubRelease);
final downloadClient = Dio();
await downloadClient.download(fastDownloadUrl, newVersionAssetPath,
onReceiveProgress: onProgress);
}
}
switch (_channel) {
case Channel.windowsInstaller:
case Channel.windowsPortable:
case Channel.macosDmg:
case Channel.linuxFlathub:
case Channel.linuxSnap:
case Channel.linuxDeb:
final updaterPath = await Util.homePathJoin(_updaterBin);
// Check the updater binary is exists
if (!await File(updaterPath).exists()) {
await launchUrl(
Uri.parse(
'https://github.com/GopeedLab/gopeed/releases/tag/v$version'),
mode: LaunchMode.externalApplication);
break;
}
/**
*Usage of updater command:
-pid int
PID of the process to update
-channel string
Update channel
-asset string
Path to the package asset
-exeDir string
Directory of the entry executable
-log string
Log file path
*/
await Process.run(updaterPath, [
"-pid",
pid.toString(),
"-channel",
_channel!.name,
"-asset",
newVersionAssetPath,
"-exeDir",
path.dirname(Platform.resolvedExecutable),
"-log",
path.join(logsDir(), "updater.log")
]);
break;
case Channel.androidApk:
await InstallPlugin.installApk(newVersionAssetPath);
break;
default:
await launchUrl(
Uri.parse(
'https://github.com/GopeedLab/gopeed/releases/tag/v$version'),
mode: LaunchMode.externalApplication);
break;
}
}
String _getAssetName(String version) {
final arch = getArch();
String commonArchName() {
return switch (arch) {
Architecture.ia32 => "386",
Architecture.x64 => "amd64",
_ => arch.name
};
}
switch (_channel) {
case Channel.windowsInstaller:
return 'Gopeed-v$version-windows-${commonArchName()}.zip';
case Channel.windowsPortable:
return 'Gopeed-v$version-windows-${commonArchName()}-portable.zip';
case Channel.macosDmg:
return 'Gopeed-v$version-macos-${commonArchName()}.dmg';
case Channel.linuxDeb:
return 'Gopeed-v$version-linux-${commonArchName()}.deb';
case Channel.androidApk:
final apkArchName = switch (arch) {
Architecture.arm => "armeabi-v7a",
Architecture.arm64 => "arm64-v8a",
Architecture.x64 => "x86_64",
_ => null
};
var apkNamePrefix = "Gopeed-v$version-android";
if (apkArchName != null) {
apkNamePrefix += "-$apkArchName";
}
return "$apkNamePrefix.apk";
default:
return "";
}
}
Future<String> _getAssetPath(String version) async {
return path.join(
(await getTemporaryDirectory()).path, _getAssetName(version));
}
+205
View File
@@ -0,0 +1,205 @@
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:crypto/crypto.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as path;
class Util {
static String? _storageDir;
static String cleanPath(String path) {
path = path.replaceAll(RegExp(r'\\'), "/");
if (path.startsWith(".")) {
path = path.substring(1);
}
if (path.startsWith("/")) {
path = path.substring(1);
}
return path;
}
static String safeDir(String path) {
if (path == "." || path == "./" || path == ".\\") {
return "";
}
return path;
}
static String safePathJoin(List<String> paths) {
return paths
.where((e) => e.isNotEmpty)
.map((e) => safeDir(e))
.join("/")
.replaceAll(RegExp(r'//'), "/");
}
static String fmtByte(int byte) {
if (byte < 0) {
return "0 B";
} else if (byte < 1024) {
return "$byte B";
} else if (byte < 1024 * 1024) {
return "${(byte / 1024).toStringAsFixed(2)} KB";
} else if (byte < 1024 * 1024 * 1024) {
return "${(byte / 1024 / 1024).toStringAsFixed(2)} MB";
} else {
return "${(byte / 1024 / 1024 / 1024).toStringAsFixed(2)} GB";
}
}
static Future<void> initStorageDir() async {
var storageDir = "";
if (Util.isWindows()) {
storageDir =
path.join(File(Platform.resolvedExecutable).parent.path, "storage");
} else if (!Util.isWeb()) {
if (Util.isLinux()) {
storageDir = File(Platform.resolvedExecutable).parent.path;
// check has write permission, if not, fallback to application support dir
try {
final testFile = File(path.join(storageDir, ".test"));
await testFile.writeAsString("test");
await testFile.delete();
} catch (e) {
storageDir = (await getApplicationSupportDirectory()).path;
}
} else {
storageDir = (await getApplicationSupportDirectory()).path;
}
}
_storageDir = storageDir;
}
static String getStorageDir() {
return _storageDir!;
}
static isAndroid() {
return !kIsWeb && Platform.isAndroid;
}
static isIOS() {
return !kIsWeb && Platform.isIOS;
}
static isMobile() {
return !kIsWeb && (Platform.isAndroid || Platform.isIOS);
}
static isDesktop() {
if (kIsWeb) {
return false;
}
return Platform.isWindows || Platform.isLinux || Platform.isMacOS;
}
static isWindows() {
return !kIsWeb && Platform.isWindows;
}
static isMacos() {
return !kIsWeb && Platform.isMacOS;
}
static isLinux() {
return !kIsWeb && Platform.isLinux;
}
static isWeb() {
return kIsWeb;
}
static supportUnixSocket() {
if (kIsWeb) {
return false;
}
return Platform.isLinux || Platform.isMacOS || Platform.isAndroid;
}
static List<String> textToLines(String text) {
if (text.isEmpty) {
return [];
}
const ls = LineSplitter();
return ls.convert(text).where((line) => line.isNotEmpty).toList();
}
// if one future complete, return the result, only all future error, return the last error
static anyOk<T>(Iterable<Future<T>> futures) {
final completer = Completer<T>();
Object lastError;
var count = futures.length;
for (var future in futures) {
future.then((value) {
if (!completer.isCompleted) {
completer.complete(value);
}
}).catchError((e) {
lastError = e;
count--;
if (count == 0) {
completer.completeError(lastError);
}
});
}
return completer.future;
}
static void Function() debounce(Function() fn, int ms) {
Timer? timer;
return () {
timer?.cancel();
timer = Timer(Duration(milliseconds: ms), fn);
};
}
static Future<String> homePathJoin(String fileName) async {
if (Util.isWindows()) {
final execPath = Platform.resolvedExecutable;
final execDir = path.dirname(execPath);
return path.join(execDir, fileName);
}
final dir = await getApplicationSupportDirectory();
return path.join(dir.path, fileName);
}
static Future<void> installAsset(String assetPath, String targetPath,
{bool executable = false}) async {
Future<List<int>> getAssetData() async {
final asset = await rootBundle.load(assetPath);
return asset.buffer.asUint8List(asset.offsetInBytes, asset.lengthInBytes);
}
// Check if target file is not installed
if (!await File(targetPath).exists()) {
final assetData = await getAssetData();
final file = File(targetPath);
await file.writeAsBytes(assetData);
// Add execute permission when file first created
if (executable && !Platform.isWindows) {
await Process.run('chmod', ['+x', targetPath]);
}
return;
}
// Check if target file needs to be updated
final assetData = await getAssetData();
if (_md5(assetData) != await _md5File(File(targetPath))) {
await File(targetPath).writeAsBytes(assetData);
return;
}
}
static String _md5(List<int> data) {
return md5.convert(data).toString();
}
static Future<String> _md5File(File file) async {
return file.openRead().transform(md5).first.toString();
}
}
+32
View File
@@ -0,0 +1,32 @@
import 'package:win32_registry/win32_registry.dart';
/// Check registry key
/// If the key does not exist or the value is different, return false
checkRegistry(String keyPath, String valueName, String value) {
RegistryKey regKey;
try {
regKey = Registry.openPath(RegistryHive.currentUser, path: keyPath);
return regKey.getValueAsString(valueName) == value;
} catch (e) {
return false;
}
}
/// Upsert registry key
/// If the key does not exist, create it
/// If the value does not exist or is different, update it
upsertRegistry(String keyPath, String valueName, String value) {
RegistryKey regKey;
try {
regKey = Registry.openPath(RegistryHive.currentUser,
path: keyPath, desiredAccessRights: AccessRights.allAccess);
} catch (e) {
regKey = Registry.currentUser.createKey(keyPath);
}
if (regKey.getValueAsString(valueName) != value) {
regKey
.createValue(RegistryValue(valueName, RegistryValueType.string, value));
}
regKey.close();
}