rustdesk/flutter/lib/models/native_model.dart

272 lines
8.8 KiB
Dart
Raw Normal View History

import 'dart:convert';
import 'dart:ffi';
2022-01-26 12:48:16 +08:00
import 'dart:io';
import 'package:device_info_plus/device_info_plus.dart';
2022-02-10 02:07:53 +08:00
import 'package:external_path/external_path.dart';
import 'package:ffi/ffi.dart';
import 'package:flutter/foundation.dart';
2022-02-10 02:07:53 +08:00
import 'package:flutter/services.dart';
2023-02-04 11:23:36 +08:00
import 'package:flutter_hbb/consts.dart';
import 'package:flutter_hbb/main.dart';
import 'package:package_info_plus/package_info_plus.dart';
import 'package:path_provider/path_provider.dart';
import '../common.dart';
import '../generated_bridge.dart';
2022-01-26 12:48:16 +08:00
final class RgbaFrame extends Struct {
2022-01-26 12:48:16 +08:00
@Uint32()
2022-02-17 15:22:14 +08:00
external int len;
external Pointer<Uint8> data;
2022-01-26 12:48:16 +08:00
}
typedef F3 = Pointer<Uint8> Function(Pointer<Utf8>, int);
typedef F3Dart = Pointer<Uint8> Function(Pointer<Utf8>, Int32);
typedef HandleEvent = Future<void> Function(Map<String, dynamic> evt);
2022-01-26 12:48:16 +08:00
2022-05-28 03:56:42 +08:00
/// FFI wrapper around the native Rust core.
/// Hides the platform differences.
2022-01-26 12:48:16 +08:00
class PlatformFFI {
String _dir = '';
// _homeDir is only needed for Android and IOS.
String _homeDir = '';
final _eventHandlers = <String, Map<String, HandleEvent>>{};
late RustdeskImpl _ffiBind;
late String _appType;
StreamEventHandler? _eventCallback;
2022-01-26 12:48:16 +08:00
PlatformFFI._();
static final PlatformFFI instance = PlatformFFI._();
final _toAndroidChannel = const MethodChannel('mChannel');
RustdeskImpl get ffiBind => _ffiBind;
F3? _session_get_rgba;
2022-05-31 14:44:06 +08:00
static get localeName => Platform.localeName;
2023-02-04 11:23:36 +08:00
static get isMain => instance._appType == kAppTypeMain;
2022-01-26 19:00:23 +08:00
static Future<String> getVersion() async {
PackageInfo packageInfo = await PackageInfo.fromPlatform();
return packageInfo.version;
}
bool registerEventHandler(
String eventName, String handlerName, HandleEvent handler) {
debugPrint('registerEventHandler $eventName $handlerName');
var handlers = _eventHandlers[eventName];
if (handlers == null) {
_eventHandlers[eventName] = {handlerName: handler};
return true;
} else {
if (handlers.containsKey(handlerName)) {
return false;
} else {
handlers[handlerName] = handler;
return true;
}
}
}
void unregisterEventHandler(String eventName, String handlerName) {
debugPrint('unregisterEventHandler $eventName $handlerName');
var handlers = _eventHandlers[eventName];
if (handlers != null) {
handlers.remove(handlerName);
}
}
String translate(String name, String locale) =>
_ffiBind.translate(name: name, locale: locale);
Uint8List? getRgba(SessionID sessionId, int display, int bufSize) {
if (_session_get_rgba == null) return null;
final sessionIdStr = sessionId.toString();
var a = sessionIdStr.toNativeUtf8();
try {
final buffer = _session_get_rgba!(a, display);
if (buffer == nullptr) {
return null;
}
final data = buffer.asTypedList(bufSize);
return data;
} finally {
malloc.free(a);
}
}
int getRgbaSize(SessionID sessionId, int display) =>
_ffiBind.sessionGetRgbaSize(sessionId: sessionId, display: display);
void nextRgba(SessionID sessionId, int display) =>
_ffiBind.sessionNextRgba(sessionId: sessionId, display: display);
void registerPixelbufferTexture(SessionID sessionId, int display, int ptr) =>
_ffiBind.sessionRegisterPixelbufferTexture(
sessionId: sessionId, display: display, ptr: ptr);
void registerGpuTexture(SessionID sessionId, int display, int ptr) =>
_ffiBind.sessionRegisterGpuTexture(
sessionId: sessionId, display: display, ptr: ptr);
2022-05-28 03:56:42 +08:00
/// Init the FFI class, loads the native Rust core library.
Future<void> init(String appType) async {
_appType = appType;
final dylib = isAndroid
2022-01-26 12:48:16 +08:00
? DynamicLibrary.open('librustdesk.so')
: isLinux
? DynamicLibrary.open('librustdesk.so')
: isWindows
? DynamicLibrary.open('librustdesk.dll')
: isMacOS
2022-11-22 20:30:22 +08:00
? DynamicLibrary.open("liblibrustdesk.dylib")
: DynamicLibrary.process();
debugPrint('initializing FFI $_appType');
2022-01-26 12:48:16 +08:00
try {
_session_get_rgba = dylib.lookupFunction<F3Dart, F3>("session_get_rgba");
try {
// SYSTEM user failed
_dir = (await getApplicationDocumentsDirectory()).path;
} catch (e) {
debugPrint('Failed to get documents directory: $e');
}
2022-05-31 22:09:36 +08:00
_ffiBind = RustdeskImpl(dylib);
if (isLinux) {
2023-02-04 11:23:36 +08:00
// Start a dbus service, no need to await
_ffiBind.mainStartDbusServer();
_ffiBind.mainStartPa();
} else if (isMacOS && isMain) {
// Start ipc service for uri links.
_ffiBind.mainStartIpcUrlServer();
2022-10-11 19:52:03 +08:00
}
2022-05-31 22:09:36 +08:00
_startListenEvent(_ffiBind); // global event
2022-04-18 17:01:45 +08:00
try {
if (isAndroid) {
// only support for android
_homeDir = (await ExternalPath.getExternalStorageDirectories())[0];
} else if (isIOS) {
_homeDir = _ffiBind.mainGetDataDirIos();
} else {
// no need to set home dir
}
2022-04-18 17:01:45 +08:00
} catch (e) {
debugPrintStack(label: 'initialize failed: $e');
2022-04-18 17:01:45 +08:00
}
2022-01-26 12:48:16 +08:00
String id = 'NA';
String name = 'Flutter';
DeviceInfoPlugin deviceInfo = DeviceInfoPlugin();
if (isAndroid) {
2022-01-26 12:48:16 +08:00
AndroidDeviceInfo androidInfo = await deviceInfo.androidInfo;
name = '${androidInfo.brand}-${androidInfo.model}';
id = androidInfo.id.hashCode.toString();
androidVersion = androidInfo.version.sdkInt;
} else if (isIOS) {
2022-01-26 12:48:16 +08:00
IosDeviceInfo iosInfo = await deviceInfo.iosInfo;
name = iosInfo.utsname.machine;
2022-01-26 12:48:16 +08:00
id = iosInfo.identifierForVendor.hashCode.toString();
} else if (isLinux) {
LinuxDeviceInfo linuxInfo = await deviceInfo.linuxInfo;
name = linuxInfo.name;
id = linuxInfo.machineId ?? linuxInfo.id;
} else if (isWindows) {
try {
// request windows build number to fix overflow on win7
windowsBuildNumber = getWindowsTargetBuildNumber();
WindowsDeviceInfo winInfo = await deviceInfo.windowsInfo;
name = winInfo.computerName;
id = winInfo.computerName;
} catch (e) {
debugPrintStack(label: "get windows device info failed: $e");
name = "unknown";
id = "unknown";
}
} else if (isMacOS) {
MacOsDeviceInfo macOsInfo = await deviceInfo.macOsInfo;
name = macOsInfo.computerName;
id = macOsInfo.systemGUID ?? '';
2022-01-26 12:48:16 +08:00
}
if (isAndroid || isIOS) {
debugPrint(
'_appType:$_appType,info1-id:$id,info2-name:$name,dir:$_dir,homeDir:$_homeDir');
} else {
debugPrint(
'_appType:$_appType,info1-id:$id,info2-name:$name,dir:$_dir');
}
if (desktopType == DesktopType.cm) {
await _ffiBind.cmInit();
}
await _ffiBind.mainDeviceId(id: id);
await _ffiBind.mainDeviceName(name: name);
await _ffiBind.mainSetHomeDir(home: _homeDir);
await _ffiBind.mainInit(appDir: _dir, customClientConfig: '');
2022-01-26 12:48:16 +08:00
} catch (e) {
debugPrintStack(label: 'initialize failed: $e');
2022-01-26 12:48:16 +08:00
}
version = await getVersion();
2022-01-26 12:48:16 +08:00
}
2022-02-03 00:53:59 +08:00
Future<bool> tryHandle(Map<String, dynamic> evt) async {
final name = evt['name'];
if (name != null) {
final handlers = _eventHandlers[name];
if (handlers != null) {
if (handlers.isNotEmpty) {
for (var handler in handlers.values) {
await handler(evt);
}
return true;
}
}
}
return false;
}
2022-05-28 03:56:42 +08:00
/// Start listening to the Rust core's events and frames.
void _startListenEvent(RustdeskImpl rustdeskImpl) {
final appType =
_appType == kAppTypeDesktopRemote ? '$_appType,$kWindowId' : _appType;
var sink = rustdeskImpl.startGlobalEventStream(appType: appType);
2023-06-09 11:32:36 +08:00
sink.listen((message) {
() async {
try {
Map<String, dynamic> event = json.decode(message);
// _tryHandle here may be more flexible than _eventCallback
if (!await tryHandle(event)) {
if (_eventCallback != null) {
await _eventCallback!(event);
}
2022-05-19 23:45:44 +08:00
}
} catch (e) {
debugPrint('json.decode fail(): $e');
}
2023-06-09 11:32:36 +08:00
}();
});
}
void setEventCallback(StreamEventHandler fun) async {
_eventCallback = fun;
}
void setRgbaCallback(void Function(int, Uint8List) fun) async {}
2022-05-19 23:45:44 +08:00
void startDesktopWebListener() {}
2022-02-17 15:22:14 +08:00
void stopDesktopWebListener() {}
2022-02-10 02:07:53 +08:00
void setMethodCallHandler(FMethod callback) {
_toAndroidChannel.setMethodCallHandler((call) async {
2022-02-10 02:07:53 +08:00
callback(call.method, call.arguments);
return null;
});
}
invokeMethod(String method, [dynamic arguments]) async {
2022-04-18 11:46:36 +08:00
if (!isAndroid) return Future<bool>(() => false);
return await _toAndroidChannel.invokeMethod(method, arguments);
2022-02-10 02:07:53 +08:00
}
void syncAndroidServiceAppDirConfigPath() {
invokeMethod(AndroidChannel.kSyncAppDirConfigPath, _dir);
}
2022-01-26 12:48:16 +08:00
}