rustdesk/flutter/lib/utils/multi_window_manager.dart

287 lines
8.2 KiB
Dart
Raw Normal View History

import 'dart:convert';
2023-01-28 09:33:57 +08:00
import 'dart:io';
import 'package:desktop_multi_window/desktop_multi_window.dart';
import 'package:flutter/foundation.dart';
2022-08-09 13:39:30 +08:00
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_hbb/common.dart';
/// must keep the order
enum WindowType { Main, RemoteDesktop, FileTransfer, PortForward, Unknown }
extension Index on int {
WindowType get windowType {
switch (this) {
case 0:
return WindowType.Main;
case 1:
return WindowType.RemoteDesktop;
case 2:
return WindowType.FileTransfer;
case 3:
return WindowType.PortForward;
default:
return WindowType.Unknown;
}
}
}
/// Window Manager
/// mainly use it in `Main Window`
/// use it in sub window is not recommended
class RustDeskMultiWindowManager {
RustDeskMultiWindowManager._();
static final instance = RustDeskMultiWindowManager._();
2022-11-05 23:41:22 +08:00
final List<int> _activeWindows = List.empty(growable: true);
final List<AsyncCallback> _windowActiveCallbacks = List.empty(growable: true);
int? _remoteDesktopWindowId;
int? _fileTransferWindowId;
int? _portForwardWindowId;
Future<dynamic> newRemoteDesktop(
String remoteId, {
String? password,
String? switch_uuid,
bool? forceRelay,
}) async {
var params = {
"type": WindowType.RemoteDesktop.index,
"id": remoteId,
"password": password,
"forceRelay": forceRelay
};
if (switch_uuid != null) {
params['switch_uuid'] = switch_uuid;
}
final msg = jsonEncode(params);
try {
final ids = await DesktopMultiWindow.getAllSubWindowIds();
if (!ids.contains(_remoteDesktopWindowId)) {
_remoteDesktopWindowId = null;
}
} on Error {
_remoteDesktopWindowId = null;
}
if (_remoteDesktopWindowId == null) {
final remoteDesktopController =
await DesktopMultiWindow.createWindow(msg);
remoteDesktopController
..setFrame(const Offset(0, 0) & const Size(1280, 720))
..center()
..setTitle(getWindowNameWithId(remoteId,
overrideType: WindowType.RemoteDesktop));
2023-01-28 09:33:57 +08:00
if (Platform.isMacOS) {
Future.microtask(() => remoteDesktopController.show());
}
2022-11-05 23:41:22 +08:00
registerActiveWindow(remoteDesktopController.windowId);
_remoteDesktopWindowId = remoteDesktopController.windowId;
} else {
return call(WindowType.RemoteDesktop, "new_remote_desktop", msg);
}
}
Future<dynamic> newFileTransfer(String remoteId, {bool? forceRelay}) async {
var msg = jsonEncode({
"type": WindowType.FileTransfer.index,
"id": remoteId,
"forceRelay": forceRelay,
});
try {
final ids = await DesktopMultiWindow.getAllSubWindowIds();
if (!ids.contains(_fileTransferWindowId)) {
_fileTransferWindowId = null;
}
} on Error {
_fileTransferWindowId = null;
}
if (_fileTransferWindowId == null) {
final fileTransferController = await DesktopMultiWindow.createWindow(msg);
fileTransferController
..setFrame(const Offset(0, 0) & const Size(1280, 720))
..center()
..setTitle(getWindowNameWithId(remoteId,
overrideType: WindowType.FileTransfer));
2023-01-28 09:33:57 +08:00
if (Platform.isMacOS) {
Future.microtask(() => fileTransferController.show());
}
2022-11-05 23:41:22 +08:00
registerActiveWindow(fileTransferController.windowId);
_fileTransferWindowId = fileTransferController.windowId;
} else {
return call(WindowType.FileTransfer, "new_file_transfer", msg);
}
}
Future<dynamic> newPortForward(String remoteId, bool isRDP,
{bool? forceRelay}) async {
final msg = jsonEncode({
"type": WindowType.PortForward.index,
"id": remoteId,
"isRDP": isRDP,
"forceRelay": forceRelay,
});
try {
final ids = await DesktopMultiWindow.getAllSubWindowIds();
if (!ids.contains(_portForwardWindowId)) {
_portForwardWindowId = null;
}
} on Error {
_portForwardWindowId = null;
}
if (_portForwardWindowId == null) {
final portForwardController = await DesktopMultiWindow.createWindow(msg);
portForwardController
..setFrame(const Offset(0, 0) & const Size(1280, 720))
..center()
..setTitle(getWindowNameWithId(remoteId,
overrideType: WindowType.PortForward));
2023-01-28 09:33:57 +08:00
if (Platform.isMacOS) {
Future.microtask(() => portForwardController.show());
}
2022-11-05 23:41:22 +08:00
registerActiveWindow(portForwardController.windowId);
_portForwardWindowId = portForwardController.windowId;
} else {
return call(WindowType.PortForward, "new_port_forward", msg);
}
}
Future<dynamic> call(WindowType type, String methodName, dynamic args) async {
int? windowId = findWindowByType(type);
if (windowId == null) {
return;
}
return await DesktopMultiWindow.invokeMethod(windowId, methodName, args);
}
int? findWindowByType(WindowType type) {
switch (type) {
case WindowType.Main:
return 0;
case WindowType.RemoteDesktop:
return _remoteDesktopWindowId;
case WindowType.FileTransfer:
return _fileTransferWindowId;
case WindowType.PortForward:
return _portForwardWindowId;
case WindowType.Unknown:
break;
}
return null;
}
void clearWindowType(WindowType type) {
switch (type) {
case WindowType.Main:
return;
case WindowType.RemoteDesktop:
_remoteDesktopWindowId = null;
break;
case WindowType.FileTransfer:
_fileTransferWindowId = null;
break;
case WindowType.PortForward:
_portForwardWindowId = null;
break;
case WindowType.Unknown:
break;
}
}
void setMethodHandler(
Future<dynamic> Function(MethodCall call, int fromWindowId)? handler) {
DesktopMultiWindow.setMethodHandler(handler);
}
2022-08-09 13:39:30 +08:00
Future<void> closeAllSubWindows() async {
await Future.wait(WindowType.values.map((e) => closeWindows(e)));
}
Future<void> closeWindows(WindowType type) async {
2022-08-09 13:39:30 +08:00
if (type == WindowType.Main) {
// skip main window, use window manager instead
return;
}
int? wId = findWindowByType(type);
if (wId != null) {
debugPrint("closing multi window: ${type.toString()}");
await saveWindowPosition(type, windowId: wId);
2022-08-09 13:39:30 +08:00
try {
final ids = await DesktopMultiWindow.getAllSubWindowIds();
if (!ids.contains(wId)) {
// no such window already
return;
}
await WindowController.fromWindowId(wId).setPreventClose(false);
await WindowController.fromWindowId(wId).close();
} catch (e) {
debugPrint("$e");
2022-08-09 13:39:30 +08:00
return;
} finally {
clearWindowType(type);
2022-08-09 13:39:30 +08:00
}
}
}
2022-11-05 23:41:22 +08:00
Future<List<int>> getAllSubWindowIds() async {
try {
final windows = await DesktopMultiWindow.getAllSubWindowIds();
return windows;
} catch (err) {
if (err is AssertionError) {
return [];
} else {
rethrow;
}
}
}
List<int> getActiveWindows() {
return _activeWindows;
}
Future<void> _notifyActiveWindow() async {
2022-11-05 23:41:22 +08:00
for (final callback in _windowActiveCallbacks) {
await callback.call();
2022-11-05 23:41:22 +08:00
}
}
Future<void> registerActiveWindow(int windowId) async {
2022-11-05 23:41:22 +08:00
if (_activeWindows.contains(windowId)) {
// ignore
} else {
_activeWindows.add(windowId);
}
await _notifyActiveWindow();
2022-11-05 23:41:22 +08:00
}
/// Remove active window which has [`windowId`]
///
2022-12-26 01:21:13 +08:00
/// [Availability]
/// This function should only be called from main window.
/// For other windows, please post a unregister(hide) event to main window handler:
/// `rustDeskWinManager.call(WindowType.Main, kWindowEventHide, {"id": windowId!});`
Future<void> unregisterActiveWindow(int windowId) async {
2022-11-05 23:41:22 +08:00
if (!_activeWindows.contains(windowId)) {
// ignore
} else {
_activeWindows.remove(windowId);
}
await _notifyActiveWindow();
2022-11-05 23:41:22 +08:00
}
void registerActiveWindowListener(AsyncCallback callback) {
2022-11-05 23:41:22 +08:00
_windowActiveCallbacks.add(callback);
}
void unregisterActiveWindowListener(AsyncCallback callback) {
2022-11-05 23:41:22 +08:00
_windowActiveCallbacks.remove(callback);
}
}
final rustDeskWinManager = RustDeskMultiWindowManager.instance;