mirror of
https://mirror.ghproxy.com/https://github.com/StarCitizenToolBox/app.git
synced 2024-12-24 01:13:40 +08:00
311 lines
10 KiB
Dart
311 lines
10 KiB
Dart
// ignore_for_file: avoid_build_context_in_providers, avoid_public_notifier_properties
|
|
import 'dart:io';
|
|
|
|
import 'package:aria2/aria2.dart';
|
|
import 'package:fluent_ui/fluent_ui.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:freezed_annotation/freezed_annotation.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'package:riverpod_annotation/riverpod_annotation.dart';
|
|
import 'package:starcitizen_doctor/common/helper/system_helper.dart';
|
|
import 'package:starcitizen_doctor/common/utils/log.dart';
|
|
import 'package:starcitizen_doctor/common/utils/provider.dart';
|
|
import 'package:starcitizen_doctor/provider/aria2c.dart';
|
|
|
|
import '../../../widgets/widgets.dart';
|
|
|
|
part 'home_downloader_ui_model.g.dart';
|
|
|
|
part 'home_downloader_ui_model.freezed.dart';
|
|
|
|
@freezed
|
|
class HomeDownloaderUIState with _$HomeDownloaderUIState {
|
|
factory HomeDownloaderUIState({
|
|
@Default([]) List<Aria2Task> tasks,
|
|
@Default([]) List<Aria2Task> waitingTasks,
|
|
@Default([]) List<Aria2Task> stoppedTasks,
|
|
Aria2GlobalStat? globalStat,
|
|
}) = _HomeDownloaderUIState;
|
|
}
|
|
|
|
extension HomeDownloaderUIStateExtension on HomeDownloaderUIState {
|
|
bool get isAvailable => globalStat != null;
|
|
}
|
|
|
|
@riverpod
|
|
class HomeDownloaderUIModel extends _$HomeDownloaderUIModel {
|
|
final DateFormat formatter = DateFormat('yyyy-MM-dd HH:mm:ss');
|
|
|
|
bool _disposed = false;
|
|
|
|
final statusMap = {
|
|
"active": S.current.downloader_info_downloading_status,
|
|
"waiting": S.current.downloader_info_waiting,
|
|
"paused": S.current.downloader_info_paused,
|
|
"error": S.current.downloader_info_download_failed,
|
|
"complete": S.current.downloader_info_download_completed,
|
|
"removed": S.current.downloader_info_deleted,
|
|
};
|
|
|
|
final listHeaderStatusMap = {
|
|
"active": S.current.downloader_title_downloading,
|
|
"waiting": S.current.downloader_info_waiting,
|
|
"stopped": S.current.downloader_title_ended,
|
|
};
|
|
|
|
@override
|
|
HomeDownloaderUIState build() {
|
|
state = HomeDownloaderUIState();
|
|
_listenDownloader();
|
|
ref.onDispose(() {
|
|
_disposed = true;
|
|
});
|
|
return state;
|
|
}
|
|
|
|
onTapButton(BuildContext context, String key) async {
|
|
final aria2cState = ref.read(aria2cModelProvider);
|
|
switch (key) {
|
|
case "pause_all":
|
|
if (!aria2cState.isRunning) return;
|
|
await aria2cState.aria2c?.pauseAll();
|
|
await aria2cState.aria2c?.saveSession();
|
|
return;
|
|
case "resume_all":
|
|
if (!aria2cState.isRunning) return;
|
|
await aria2cState.aria2c?.unpauseAll();
|
|
await aria2cState.aria2c?.saveSession();
|
|
return;
|
|
case "cancel_all":
|
|
final userOK = await showConfirmDialogs(
|
|
context,
|
|
S.current.downloader_action_confirm_cancel_all_tasks,
|
|
Text(S.current.downloader_info_manual_file_deletion_note));
|
|
if (userOK == true) {
|
|
if (!aria2cState.isRunning) return;
|
|
try {
|
|
for (var value in [...state.tasks, ...state.waitingTasks]) {
|
|
await aria2cState.aria2c?.remove(value.gid!);
|
|
}
|
|
await aria2cState.aria2c?.saveSession();
|
|
} catch (e) {
|
|
dPrint("DownloadsUIModel cancel_all Error: $e");
|
|
}
|
|
}
|
|
return;
|
|
case "settings":
|
|
_showDownloadSpeedSettings(context);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int getTasksLen() {
|
|
return state.tasks.length +
|
|
state.waitingTasks.length +
|
|
state.stoppedTasks.length;
|
|
}
|
|
|
|
(Aria2Task, String, bool) getTaskAndType(int index) {
|
|
final tempList = <Aria2Task>[
|
|
...state.tasks,
|
|
...state.waitingTasks,
|
|
...state.stoppedTasks
|
|
];
|
|
if (index >= 0 && index < state.tasks.length) {
|
|
return (tempList[index], "active", index == 0);
|
|
}
|
|
if (index >= state.tasks.length &&
|
|
index < state.tasks.length + state.waitingTasks.length) {
|
|
return (tempList[index], "waiting", index == state.tasks.length);
|
|
}
|
|
if (index >= state.tasks.length + state.waitingTasks.length &&
|
|
index < tempList.length) {
|
|
return (
|
|
tempList[index],
|
|
"stopped",
|
|
index == state.tasks.length + state.waitingTasks.length
|
|
);
|
|
}
|
|
throw Exception("Index out of range or element is null");
|
|
}
|
|
|
|
static MapEntry<String, String> getTaskTypeAndName(Aria2Task task) {
|
|
if (task.bittorrent == null) {
|
|
String uri = task.files?[0]['uris'][0]['uri'] as String;
|
|
return MapEntry("url", uri.split('/').last);
|
|
} else if (task.bittorrent != null) {
|
|
if (task.bittorrent!.containsKey('info')) {
|
|
var btName = task.bittorrent?["info"]["name"];
|
|
return MapEntry("torrent", btName ?? 'torrent');
|
|
} else {
|
|
return MapEntry("magnet", '[METADATA]${task.infoHash}');
|
|
}
|
|
} else {
|
|
return const MapEntry("metaLink", '==========metaLink============');
|
|
}
|
|
}
|
|
|
|
int getETA(Aria2Task task) {
|
|
if (task.downloadSpeed == null || task.downloadSpeed == 0) return 0;
|
|
final remainingBytes =
|
|
(task.totalLength ?? 0) - (task.completedLength ?? 0);
|
|
return remainingBytes ~/ (task.downloadSpeed!);
|
|
}
|
|
|
|
Future<void> resumeTask(String? gid) async {
|
|
final aria2c = ref.read(aria2cModelProvider).aria2c;
|
|
if (gid != null) {
|
|
await aria2c?.unpause(gid);
|
|
}
|
|
}
|
|
|
|
Future<void> pauseTask(String? gid) async {
|
|
final aria2c = ref.read(aria2cModelProvider).aria2c;
|
|
if (gid != null) {
|
|
await aria2c?.pause(gid);
|
|
}
|
|
}
|
|
|
|
Future<void> cancelTask(BuildContext context, String? gid) async {
|
|
await Future.delayed(const Duration(milliseconds: 300));
|
|
if (gid != null) {
|
|
if (!context.mounted) return;
|
|
final ok = await showConfirmDialogs(
|
|
context,
|
|
S.current.downloader_action_confirm_cancel_download,
|
|
Text(S.current.downloader_info_manual_file_deletion_note));
|
|
if (ok == true) {
|
|
final aria2c = ref.read(aria2cModelProvider).aria2c;
|
|
await aria2c?.remove(gid);
|
|
await aria2c?.saveSession();
|
|
}
|
|
}
|
|
}
|
|
|
|
List<Aria2File> getFilesFormTask(Aria2Task task) {
|
|
List<Aria2File> l = [];
|
|
if (task.files != null) {
|
|
for (var element in task.files!) {
|
|
final f = Aria2File.fromJson(element);
|
|
l.add(f);
|
|
}
|
|
}
|
|
return l;
|
|
}
|
|
|
|
openFolder(Aria2Task task) {
|
|
final f = getFilesFormTask(task).firstOrNull;
|
|
if (f != null) {
|
|
SystemHelper.openDir(File(f.path!).absolute.path.replaceAll("/", "\\"));
|
|
}
|
|
}
|
|
|
|
_listenDownloader() async {
|
|
try {
|
|
while (true) {
|
|
final aria2cState = ref.read(aria2cModelProvider);
|
|
if (_disposed) return;
|
|
if (aria2cState.isRunning) {
|
|
final aria2c = aria2cState.aria2c!;
|
|
final tasks = await aria2c.tellActive();
|
|
final waitingTasks = await aria2c.tellWaiting(0, 1000000);
|
|
final stoppedTasks = await aria2c.tellStopped(0, 1000000);
|
|
final globalStat = await aria2c.getGlobalStat();
|
|
state = state.copyWith(
|
|
tasks: tasks,
|
|
waitingTasks: waitingTasks,
|
|
stoppedTasks: stoppedTasks,
|
|
globalStat: globalStat,
|
|
);
|
|
} else {
|
|
state = state.copyWith(
|
|
tasks: [],
|
|
waitingTasks: [],
|
|
stoppedTasks: [],
|
|
globalStat: null,
|
|
);
|
|
}
|
|
await Future.delayed(const Duration(seconds: 1));
|
|
}
|
|
} catch (e) {
|
|
dPrint("[DownloadsUIModel]._listenDownloader Error: $e");
|
|
}
|
|
}
|
|
|
|
Future<void> _showDownloadSpeedSettings(BuildContext context) async {
|
|
final box = await Hive.openBox("app_conf");
|
|
|
|
final upCtrl = TextEditingController(
|
|
text: box.get("downloader_up_limit", defaultValue: ""));
|
|
final downCtrl = TextEditingController(
|
|
text: box.get("downloader_down_limit", defaultValue: ""));
|
|
|
|
final ifr = FilteringTextInputFormatter.allow(RegExp(r'^\d*[km]?$'));
|
|
|
|
if (!context.mounted) return;
|
|
final ok = await showConfirmDialogs(
|
|
context,
|
|
S.current.downloader_speed_limit_settings,
|
|
Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Text(
|
|
S.current.downloader_info_p2p_network_note,
|
|
style: TextStyle(
|
|
fontSize: 14,
|
|
color: Colors.white.withOpacity(.6),
|
|
),
|
|
),
|
|
const SizedBox(height: 24),
|
|
Text(S.current.downloader_info_download_unit_input_prompt),
|
|
const SizedBox(height: 12),
|
|
Text(S.current.downloader_input_upload_speed_limit),
|
|
const SizedBox(height: 6),
|
|
TextFormBox(
|
|
placeholder: "1、100k、10m、0",
|
|
controller: upCtrl,
|
|
placeholderStyle: TextStyle(color: Colors.white.withOpacity(.6)),
|
|
inputFormatters: [ifr],
|
|
),
|
|
const SizedBox(height: 12),
|
|
Text(S.current.downloader_input_download_speed_limit),
|
|
const SizedBox(height: 6),
|
|
TextFormBox(
|
|
placeholder: "1、100k、10m、0",
|
|
controller: downCtrl,
|
|
placeholderStyle: TextStyle(color: Colors.white.withOpacity(.6)),
|
|
inputFormatters: [ifr],
|
|
),
|
|
const SizedBox(height: 24),
|
|
Text(
|
|
S.current.downloader_input_info_p2p_upload_note,
|
|
style: TextStyle(
|
|
fontSize: 13,
|
|
color: Colors.white.withOpacity(.6),
|
|
),
|
|
)
|
|
],
|
|
));
|
|
if (ok == true) {
|
|
final aria2cState = ref.read(aria2cModelProvider);
|
|
final aria2cModel = ref.read(aria2cModelProvider.notifier);
|
|
await aria2cModel
|
|
.launchDaemon(appGlobalState.applicationBinaryModuleDir!);
|
|
final aria2c = aria2cState.aria2c!;
|
|
final upByte = aria2cModel.textToByte(upCtrl.text.trim());
|
|
final downByte = aria2cModel.textToByte(downCtrl.text.trim());
|
|
final r = await aria2c
|
|
.changeGlobalOption(Aria2Option()
|
|
..maxOverallUploadLimit = upByte
|
|
..maxOverallDownloadLimit = downByte)
|
|
.unwrap();
|
|
if (r != null) {
|
|
await box.put('downloader_up_limit', upCtrl.text.trim());
|
|
await box.put('downloader_down_limit', downCtrl.text.trim());
|
|
}
|
|
}
|
|
}
|
|
}
|