mirror of
https://github.com/Auties00/Reboot-Launcher.git
synced 2026-01-13 19:22:22 +01:00
289 lines
10 KiB
Dart
289 lines
10 KiB
Dart
import 'dart:async';
|
|
import 'dart:io';
|
|
|
|
import 'package:fluent_ui/fluent_ui.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:get_storage/get_storage.dart';
|
|
import 'package:path/path.dart';
|
|
import 'package:reboot_common/common.dart';
|
|
import 'package:reboot_launcher/main.dart';
|
|
import 'package:reboot_launcher/src/messenger/info_bar.dart';
|
|
import 'package:reboot_launcher/src/util/translations.dart';
|
|
import 'package:version/version.dart';
|
|
import 'package:path/path.dart' as path;
|
|
|
|
class DllController extends GetxController {
|
|
static const String storageName = "v2_dll_storage";
|
|
|
|
late final GetStorage? _storage;
|
|
late final TextEditingController customGameServerDll;
|
|
late final TextEditingController unrealEngineConsoleDll;
|
|
late final TextEditingController backendDll;
|
|
late final TextEditingController memoryLeakDll;
|
|
late final TextEditingController gameServerPort;
|
|
late final Rx<UpdateTimer> timer;
|
|
late final TextEditingController beforeS20Mirror;
|
|
late final TextEditingController aboveS20Mirror;
|
|
late final RxBool customGameServer;
|
|
late final RxnInt timestamp;
|
|
late final Rx<UpdateStatus> status;
|
|
InfoBarEntry? infoBarEntry;
|
|
|
|
DllController() {
|
|
_storage = appWithNoStorage ? null : GetStorage(storageName);
|
|
customGameServerDll = _createController("game_server", InjectableDll.gameServer);
|
|
unrealEngineConsoleDll = _createController("unreal_engine_console", InjectableDll.console);
|
|
backendDll = _createController("backend", InjectableDll.auth);
|
|
memoryLeakDll = _createController("memory_leak", InjectableDll.memoryLeak);
|
|
gameServerPort = TextEditingController(text: _storage?.read("game_server_port") ?? kDefaultGameServerPort);
|
|
gameServerPort.addListener(() => _storage?.write("game_server_port", gameServerPort.text));
|
|
final timerIndex = _storage?.read("timer");
|
|
timer = Rx(timerIndex == null ? UpdateTimer.hour : UpdateTimer.values.elementAt(timerIndex));
|
|
timer.listen((value) => _storage?.write("timer", value.index));
|
|
beforeS20Mirror = TextEditingController(text: _storage?.read("update_url") ?? kRebootBelowS20DownloadUrl);
|
|
beforeS20Mirror.addListener(() => _storage?.write("update_url", beforeS20Mirror.text));
|
|
aboveS20Mirror = TextEditingController(text: _storage?.read("old_update_url") ?? kRebootAboveS20DownloadUrl);
|
|
aboveS20Mirror.addListener(() => _storage?.write("new_update_url", aboveS20Mirror.text));
|
|
status = Rx(UpdateStatus.waiting);
|
|
customGameServer = RxBool(_storage?.read("custom_game_server") ?? false);
|
|
customGameServer.listen((value) => _storage?.write("custom_game_server", value));
|
|
timestamp = RxnInt(_storage?.read("ts"));
|
|
timestamp.listen((value) => _storage?.write("ts", value));
|
|
}
|
|
|
|
TextEditingController _createController(String key, InjectableDll dll) {
|
|
final controller = TextEditingController(text: _storage?.read(key) ?? getDefaultDllPath(dll));
|
|
controller.addListener(() => _storage?.write(key, controller.text));
|
|
return controller;
|
|
}
|
|
|
|
void resetGame() {
|
|
customGameServerDll.text = getDefaultDllPath(InjectableDll.gameServer);
|
|
unrealEngineConsoleDll.text = getDefaultDllPath(InjectableDll.console);
|
|
backendDll.text = getDefaultDllPath(InjectableDll.auth);
|
|
}
|
|
|
|
void resetServer() {
|
|
gameServerPort.text = kDefaultGameServerPort;
|
|
timer.value = UpdateTimer.hour;
|
|
beforeS20Mirror.text = kRebootBelowS20DownloadUrl;
|
|
aboveS20Mirror.text = kRebootAboveS20DownloadUrl;
|
|
status.value = UpdateStatus.waiting;
|
|
customGameServer.value = false;
|
|
timestamp.value = null;
|
|
updateGameServerDll();
|
|
}
|
|
|
|
Future<bool> updateGameServerDll({bool force = false, bool silent = false}) async {
|
|
try {
|
|
if(customGameServer.value) {
|
|
status.value = UpdateStatus.success;
|
|
return true;
|
|
}
|
|
|
|
final needsUpdate = await hasRebootDllUpdate(
|
|
timestamp.value,
|
|
hours: timer.value.hours,
|
|
force: force
|
|
);
|
|
if(!needsUpdate) {
|
|
status.value = UpdateStatus.success;
|
|
return true;
|
|
}
|
|
|
|
if(!silent) {
|
|
infoBarEntry = showRebootInfoBar(
|
|
translations.downloadingDll("reboot"),
|
|
loading: true,
|
|
duration: null
|
|
);
|
|
}
|
|
await Future.wait(
|
|
[
|
|
downloadRebootDll(rebootBeforeS20DllFile, beforeS20Mirror.text),
|
|
downloadRebootDll(rebootAboveS20DllFile, aboveS20Mirror.text),
|
|
Future.delayed(const Duration(seconds: 1))
|
|
],
|
|
eagerError: false
|
|
);
|
|
timestamp.value = DateTime.now().millisecondsSinceEpoch;
|
|
status.value = UpdateStatus.success;
|
|
infoBarEntry?.close();
|
|
if(!silent) {
|
|
infoBarEntry = showRebootInfoBar(
|
|
translations.downloadDllSuccess("reboot"),
|
|
severity: InfoBarSeverity.success,
|
|
duration: infoBarShortDuration
|
|
);
|
|
}
|
|
return true;
|
|
}catch(message) {
|
|
infoBarEntry?.close();
|
|
var error = message.toString();
|
|
error = error.contains(": ") ? error.substring(error.indexOf(": ") + 2) : error;
|
|
error = error.toLowerCase();
|
|
status.value = UpdateStatus.error;
|
|
infoBarEntry = showRebootInfoBar(
|
|
translations.downloadDllError(error.toString(), "reboot.dll"),
|
|
duration: infoBarLongDuration,
|
|
severity: InfoBarSeverity.error,
|
|
action: Button(
|
|
onPressed: () async {
|
|
infoBarEntry?.close();
|
|
updateGameServerDll(
|
|
force: true,
|
|
silent: silent
|
|
);
|
|
},
|
|
child: Text(translations.downloadDllRetry),
|
|
)
|
|
);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
(File, bool) getInjectableData(Version version, InjectableDll dll) {
|
|
final defaultPath = canonicalize(getDefaultDllPath(dll));
|
|
switch(dll){
|
|
case InjectableDll.gameServer:
|
|
if(customGameServer.value) {
|
|
return (File(customGameServerDll.text), true);
|
|
}
|
|
|
|
return (version.major >= 20 ? rebootAboveS20DllFile : rebootBeforeS20DllFile, false);
|
|
case InjectableDll.console:
|
|
final ue4ConsoleFile = File(unrealEngineConsoleDll.text);
|
|
return (ue4ConsoleFile, canonicalize(ue4ConsoleFile.path) != defaultPath);
|
|
case InjectableDll.auth:
|
|
final backendFile = File(backendDll.text);
|
|
return (backendFile, canonicalize(backendFile.path) != defaultPath);
|
|
case InjectableDll.memoryLeak:
|
|
final memoryFile = File(memoryLeakDll.text);
|
|
return (memoryFile, canonicalize(memoryFile.path) != defaultPath);
|
|
}
|
|
}
|
|
|
|
TextEditingController getDllEditingController(InjectableDll dll) {
|
|
switch(dll) {
|
|
case InjectableDll.console:
|
|
return unrealEngineConsoleDll;
|
|
case InjectableDll.auth:
|
|
return backendDll;
|
|
case InjectableDll.gameServer:
|
|
return customGameServerDll;
|
|
case InjectableDll.memoryLeak:
|
|
return memoryLeakDll;
|
|
}
|
|
}
|
|
|
|
String getDefaultDllPath(InjectableDll dll) {
|
|
switch(dll) {
|
|
case InjectableDll.console:
|
|
return "${dllsDirectory.path}\\console.dll";
|
|
case InjectableDll.auth:
|
|
return "${dllsDirectory.path}\\cobalt.dll";
|
|
case InjectableDll.gameServer:
|
|
return "${dllsDirectory.path}\\reboot.dll";
|
|
case InjectableDll.memoryLeak:
|
|
return "${dllsDirectory.path}\\memory.dll";
|
|
}
|
|
}
|
|
|
|
Future<bool> download(InjectableDll dll, String filePath, {bool silent = false, bool force = false}) async {
|
|
log("[DLL] Asking for $dll at $filePath(silent: $silent, force: $force)");
|
|
InfoBarEntry? entry;
|
|
try {
|
|
if (dll == InjectableDll.gameServer) {
|
|
return await updateGameServerDll(silent: silent);
|
|
}
|
|
|
|
if(!force && File(filePath).existsSync()) {
|
|
log("[DLL] File already exists");
|
|
return true;
|
|
}
|
|
|
|
final fileNameWithoutExtension = basenameWithoutExtension(filePath);
|
|
if(!silent) {
|
|
entry = showRebootInfoBar(
|
|
translations.downloadingDll(fileNameWithoutExtension),
|
|
loading: true,
|
|
duration: null
|
|
);
|
|
}
|
|
await downloadDependency(dll, filePath);
|
|
entry?.close();
|
|
if(!silent) {
|
|
entry = await showRebootInfoBar(
|
|
translations.downloadDllSuccess(fileNameWithoutExtension),
|
|
severity: InfoBarSeverity.success,
|
|
duration: infoBarShortDuration
|
|
);
|
|
}
|
|
return true;
|
|
}catch(message) {
|
|
log("[DLL] Error: $message");
|
|
entry?.close();
|
|
var error = message.toString();
|
|
error =
|
|
error.contains(": ") ? error.substring(error.indexOf(": ") + 2) : error;
|
|
error = error.toLowerCase();
|
|
final completer = Completer();
|
|
await showRebootInfoBar(
|
|
translations.downloadDllError(error.toString(), dll.name),
|
|
duration: infoBarLongDuration,
|
|
severity: InfoBarSeverity.error,
|
|
onDismissed: () => completer.complete(null),
|
|
action: Button(
|
|
onPressed: () async {
|
|
await download(dll, filePath, silent: silent, force: force);
|
|
completer.complete(null);
|
|
},
|
|
child: Text(translations.downloadDllRetry),
|
|
)
|
|
);
|
|
await completer.future;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void guardFiles() {
|
|
for(final injectable in InjectableDll.values) {
|
|
final controller = getDllEditingController(injectable);
|
|
final defaultPath = getDefaultDllPath(injectable);
|
|
if (path.equals(controller.text, defaultPath)) {
|
|
download(injectable, controller.text);
|
|
}
|
|
controller.addListener(() async {
|
|
try {
|
|
if (!path.equals(controller.text, defaultPath)) {
|
|
return;
|
|
}
|
|
|
|
final filePath = controller.text;
|
|
await for(final event in File(filePath).parent.watch(events: FileSystemEvent.delete | FileSystemEvent.move)) {
|
|
if (path.equals(event.path, filePath)) {
|
|
await download(injectable, filePath);
|
|
}
|
|
}
|
|
} catch(_) {
|
|
// Ignore
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
extension _UpdateTimerExtension on UpdateTimer {
|
|
int get hours {
|
|
switch(this) {
|
|
case UpdateTimer.never:
|
|
return -1;
|
|
case UpdateTimer.hour:
|
|
return 1;
|
|
case UpdateTimer.day:
|
|
return 24;
|
|
case UpdateTimer.week:
|
|
return 24 * 7;
|
|
}
|
|
}
|
|
} |