概述
Flutter 桌面平台桥接技术使 Flutter 应用能够在 Windows、macOS 和 Linux 等桌面平台上运行，并与系统 API 进行深度集成。本文将深入探讨 Flutter 与各桌面平台的桥接技术，帮助开发者构建功能丰富的桌面应用。
Windows 平台桥接
1. Windows API 集成
// Windows API桥接管理器
class WindowsAPIBridge {
static const MethodChannel _channel = MethodChannel('windows_api_bridge');
// 获取系统信息
static Future<Map<String, dynamic>> getSystemInfo() async {
try {
final result = await _channel.invokeMethod('getSystemInfo');
return Map<String, dynamic>.from(result);
} on PlatformException catch (e) {
throw Exception('Failed to get system info: ${e.message}');
}
}
// 注册系统热键
static Future<bool> registerHotKey(int id, int modifiers, int virtualKey) async {
try {
final result = await _channel.invokeMethod('registerHotKey', {
'id': id,
'modifiers': modifiers,
'virtualKey': virtualKey,
});
return result as bool;
} on PlatformException catch (e) {
throw Exception('Failed to register hotkey: ${e.message}');
}
}
// 注销系统热键
static Future<bool> unregisterHotKey(int id) async {
try {
final result = await _channel.invokeMethod('unregisterHotKey', {'id': id});
return result as bool;
} on PlatformException catch (e) {
throw Exception('Failed to unregister hotkey: ${e.message}');
}
}
// 显示文件选择对话框
static Future<String?> showFilePicker({
String? initialDirectory,
String? filter,
bool allowMultiple = false,
}) async {
try {
final result = await _channel.invokeMethod('showFilePicker', {
'initialDirectory': initialDirectory,
'filter': filter,
'allowMultiple': allowMultiple,
});
return result as String?;
} on PlatformException catch (e) {
throw Exception('Failed to show file picker: ${e.message}');
}
}
// 获取窗口句柄
static Future<int?> getWindowHandle() async {
try {
final result = await _channel.invokeMethod('getWindowHandle');
return result as int?;
} on PlatformException catch (e) {
throw Exception('Failed to get window handle: ${e.message}');
}
}
// 设置窗口属性
static Future<void> setWindowProperties(Map<String, dynamic> properties) async {
try {
await _channel.invokeMethod('setWindowProperties', properties);
} on PlatformException catch (e) {
throw Exception('Failed to set window properties: ${e.message}');
}
}
// 注册系统托盘
static Future<void> registerSystemTray({
required String iconPath,
String? tooltip,
}) async {
try {
await _channel.invokeMethod('registerSystemTray', {
'iconPath': iconPath,
'tooltip': tooltip,
});
} on PlatformException catch (e) {
throw Exception('Failed to register system tray: ${e.message}');
}
}
// 显示系统通知
static Future<void> showNotification({
required String title,
required String body,
String? iconPath,
}) async {
try {
await _channel.invokeMethod('showNotification', {
'title': title,
'body': body,
'iconPath': iconPath,
});
} on PlatformException catch (e) {
throw Exception('Failed to show notification: ${e.message}');
}
}
}2. Windows 文件系统集成
// Windows文件系统集成
class WindowsFileSystemIntegration {
static const MethodChannel _channel = MethodChannel('windows_file_system');
// 监听文件变化
static Stream<FileChangeEvent> watchFileChanges(String path) {
final eventChannel = EventChannel('file_watch_$path');
return eventChannel.receiveBroadcastStream().map((event) {
return FileChangeEvent(
path: event['path'] as String,
type: FileChangeType.values[event['type'] as int],
timestamp: DateTime.fromMillisecondsSinceEpoch(event['timestamp'] as int),
);
});
}
// 创建文件关联
static Future<bool> createFileAssociation({
required String extension,
required String description,
required String executablePath,
String? iconPath,
}) async {
try {
final result = await _channel.invokeMethod('createFileAssociation', {
'extension': extension,
'description': description,
'executablePath': executablePath,
'iconPath': iconPath,
});
return result as bool;
} on PlatformException catch (e) {
throw Exception('Failed to create file association: ${e.message}');
}
}
// 获取文件属性
static Future<FileAttributes> getFileAttributes(String path) async {
try {
final result = await _channel.invokeMethod('getFileAttributes', {'path': path});
return FileAttributes(
isReadOnly: result['isReadOnly'] as bool,
isHidden: result['isHidden'] as bool,
isSystem: result['isSystem'] as bool,
creationTime: DateTime.fromMillisecondsSinceEpoch(result['creationTime'] as int),
lastAccessTime: DateTime.fromMillisecondsSinceEpoch(result['lastAccessTime'] as int),
lastWriteTime: DateTime.fromMillisecondsSinceEpoch(result['lastWriteTime'] as int),
);
} on PlatformException catch (e) {
throw Exception('Failed to get file attributes: ${e.message}');
}
}
// 设置文件属性
static Future<void> setFileAttributes(String path, FileAttributes attributes) async {
try {
await _channel.invokeMethod('setFileAttributes', {
'path': path,
'isReadOnly': attributes.isReadOnly,
'isHidden': attributes.isHidden,
'isSystem': attributes.isSystem,
});
} on PlatformException catch (e) {
throw Exception('Failed to set file attributes: ${e.message}');
}
}
}
// 文件变化事件
class FileChangeEvent {
final String path;
final FileChangeType type;
final DateTime timestamp;
FileChangeEvent({
required this.path,
required this.type,
required this.timestamp,
});
}
enum FileChangeType {
created,
modified,
deleted,
renamed,
}
// 文件属性
class FileAttributes {
final bool isReadOnly;
final bool isHidden;
final bool isSystem;
final DateTime creationTime;
final DateTime lastAccessTime;
final DateTime lastWriteTime;
FileAttributes({
required this.isReadOnly,
required this.isHidden,
required this.isSystem,
required this.creationTime,
required this.lastAccessTime,
required this.lastWriteTime,
});
}macOS 平台桥接
1. macOS API 集成
// macOS API桥接管理器
class MacOSAPIBridge {
static const MethodChannel _channel = MethodChannel('macos_api_bridge');
// 获取系统信息
static Future<Map<String, dynamic>> getSystemInfo() async {
try {
final result = await _channel.invokeMethod('getSystemInfo');
return Map<String, dynamic>.from(result);
} on PlatformException catch (e) {
throw Exception('Failed to get system info: ${e.message}');
}
}
// 注册全局快捷键
static Future<bool> registerGlobalShortcut({
required String key,
required List<String> modifiers,
required Function() handler,
}) async {
try {
final callbackId = 'shortcut_${DateTime.now().millisecondsSinceEpoch}';
await _channel.invokeMethod('registerGlobalShortcut', {
'key': key,
'modifiers': modifiers,
'callbackId': callbackId,
});
// 注册回调处理器
_channel.setMethodCallHandler((call) async {
if (call.method == 'onGlobalShortcut' && call.arguments['callbackId'] == callbackId) {
handler();
}
});
return true;
} on PlatformException catch (e) {
throw Exception('Failed to register global shortcut: ${e.message}');
}
}
// 显示原生对话框
static Future<DialogResult> showNativeDialog({
required String title,
required String message,
DialogType type = DialogType.information,
List<DialogButton> buttons = const [DialogButton.ok],
}) async {
try {
final result = await _channel.invokeMethod('showNativeDialog', {
'title': title,
'message': message,
'type': type.index,
'buttons': buttons.map((b) => b.toMap()).toList(),
});
return DialogResult(
buttonIndex: result['buttonIndex'] as int,
buttonTitle: result['buttonTitle'] as String,
);
} on PlatformException catch (e) {
throw Exception('Failed to show native dialog: ${e.message}');
}
}
// 访问菜单栏
static Future<void> setMenuBar(List<MenuItem> menuItems) async {
try {
await _channel.invokeMethod('setMenuBar', {
'menuItems': menuItems.map((item) => item.toMap()).toList(),
});
} on PlatformException catch (e) {
throw Exception('Failed to set menu bar: ${e.message}');
}
}
// 访问Dock
static Future<void> setDockIcon(String iconPath) async {
try {
await _channel.invokeMethod('setDockIcon', {'iconPath': iconPath});
} on PlatformException catch (e) {
throw Exception('Failed to set dock icon: ${e.message}');
}
}
static Future<void> setDockBadge(String badge) async {
try {
await _channel.invokeMethod('setDockBadge', {'badge': badge});
} on PlatformException catch (e) {
throw Exception('Failed to set dock badge: ${e.message}');
}
}
// 访问通知中心
static Future<void> showNotification({
required String title,
required String subtitle,
required String body,
String? sound,
}) async {
try {
await _channel.invokeMethod('showNotification', {
'title': title,
'subtitle': subtitle,
'body': body,
'sound': sound,
});
} on PlatformException catch (e) {
throw Exception('Failed to show notification: ${e.message}');
}
}
}
// 对话框类型
enum DialogType {
information,
warning,
error,
question,
}
// 对话框按钮
class DialogButton {
static const DialogButton ok = DialogButton('OK');
static const DialogButton cancel = DialogButton('Cancel');
static const DialogButton yes = DialogButton('Yes');
static const DialogButton no = DialogButton('No');
final String title;
const DialogButton(this.title);
Map<String, dynamic> toMap() => {'title': title};
}
// 对话框结果
class DialogResult {
final int buttonIndex;
final String buttonTitle;
DialogResult({
required this.buttonIndex,
required this.buttonTitle,
});
}
// 菜单项
class MenuItem {
final String title;
final List<MenuItem>? submenu;
final Function()? onPressed;
final bool isSeparator;
final String? shortcut;
MenuItem({
required this.title,
this.submenu,
this.onPressed,
this.isSeparator = false,
this.shortcut,
});
Map<String, dynamic> toMap() => {
'title': title,
'submenu': submenu?.map((item) => item.toMap()).toList(),
'isSeparator': isSeparator,
'shortcut': shortcut,
};
}2. macOS 文件系统集成
// macOS文件系统集成
class MacOSFileSystemIntegration {
static const MethodChannel _channel = MethodChannel('macos_file_system');
// 访问Finder标签
static Future<List<String>> getFileTags(String path) async {
try {
final result = await _channel.invokeMethod('getFileTags', {'path': path});
return List<String>.from(result);
} on PlatformException catch (e) {
throw Exception('Failed to get file tags: ${e.message}');
}
}
static Future<void> setFileTags(String path, List<String> tags) async {
try {
await _channel.invokeMethod('setFileTags', {
'path': path,
'tags': tags,
});
} on PlatformException catch (e) {
throw Exception('Failed to set file tags: ${e.message}');
}
}
// 访问Spotlight搜索
static Future<List<SearchResult>> spotlightSearch({
required String query,
String? directory,
int limit = 50,
}) async {
try {
final result = await _channel.invokeMethod('spotlightSearch', {
'query': query,
'directory': directory,
'limit': limit,
});
return (result as List).map((item) => SearchResult(
path: item['path'] as String,
title: item['title'] as String,
contentType: item['contentType'] as String,
lastModified: DateTime.fromMillisecondsSinceEpoch(item['lastModified'] as int),
)).toList();
} on PlatformException catch (e) {
throw Exception('Failed to perform spotlight search: ${e.message}');
}
}
// 访问Quick Look
static Future<void> showQuickLook(List<String> paths) async {
try {
await _channel.invokeMethod('showQuickLook', {'paths': paths});
} on PlatformException catch (e) {
throw Exception('Failed to show quick look: ${e.message}');
}
}
}
// 搜索结果
class SearchResult {
final String path;
final String title;
final String contentType;
final DateTime lastModified;
SearchResult({
required this.path,
required this.title,
required this.contentType,
required this.lastModified,
});
}Linux 平台桥接
1. Linux API 集成
// Linux API桥接管理器
class LinuxAPIBridge {
static const MethodChannel _channel = MethodChannel('linux_api_bridge');
// 获取系统信息
static Future<Map<String, dynamic>> getSystemInfo() async {
try {
final result = await _channel.invokeMethod('getSystemInfo');
return Map<String, dynamic>.from(result);
} on PlatformException catch (e) {
throw Exception('Failed to get system info: ${e.message}');
}
}
// 访问系统托盘
static Future<void> createSystemTrayIcon({
required String iconPath,
String? tooltip,
List<TrayMenuItem>? menuItems,
}) async {
try {
await _channel.invokeMethod('createSystemTrayIcon', {
'iconPath': iconPath,
'tooltip': tooltip,
'menuItems': menuItems?.map((item) => item.toMap()).toList(),
});
} on PlatformException catch (e) {
throw Exception('Failed to create system tray icon: ${e.message}');
}
}
// 访问桌面通知
static Future<void> showNotification({
required String title,
required String body,
String? iconPath,
int timeout = 5000,
}) async {
try {
await _channel.invokeMethod('showNotification', {
'title': title,
'body': body,
'iconPath': iconPath,
'timeout': timeout,
});
} on PlatformException catch (e) {
throw Exception('Failed to show notification: ${e.message}');
}
}
// 访问系统主题
static Future<SystemTheme> getSystemTheme() async {
try {
final result = await _channel.invokeMethod('getSystemTheme');
return SystemTheme(
themeName: result['themeName'] as String,
isDark: result['isDark'] as bool,
primaryColor: result['primaryColor'] as String?,
accentColor: result['accentColor'] as String?,
);
} on PlatformException catch (e) {
throw Exception('Failed to get system theme: ${e.message}');
}
}
// 监听系统主题变化
static Stream<SystemTheme> watchSystemTheme() {
final eventChannel = EventChannel('system_theme_changes');
return eventChannel.receiveBroadcastStream().map((event) {
return SystemTheme(
themeName: event['themeName'] as String,
isDark: event['isDark'] as bool,
primaryColor: event['primaryColor'] as String?,
accentColor: event['accentColor'] as String?,
);
});
}
// 访问系统服务
static Future<bool> isSystemServiceRunning(String serviceName) async {
try {
final result = await _channel.invokeMethod('isSystemServiceRunning', {
'serviceName': serviceName,
});
return result as bool;
} on PlatformException catch (e) {
throw Exception('Failed to check service status: ${e.message}');
}
}
static Future<void> startSystemService(String serviceName) async {
try {
await _channel.invokeMethod('startSystemService', {'serviceName': serviceName});
} on PlatformException catch (e) {
throw Exception('Failed to start service: ${e.message}');
}
}
static Future<void> stopSystemService(String serviceName) async {
try {
await _channel.invokeMethod('stopSystemService', {'serviceName': serviceName});
} on PlatformException catch (e) {
throw Exception('Failed to stop service: ${e.message}');
}
}
}
// 系统托盘菜单项
class TrayMenuItem {
final String title;
final Function()? onPressed;
final bool isSeparator;
final List<TrayMenuItem>? submenu;
TrayMenuItem({
required this.title,
this.onPressed,
this.isSeparator = false,
this.submenu,
});
Map<String, dynamic> toMap() => {
'title': title,
'isSeparator': isSeparator,
'submenu': submenu?.map((item) => item.toMap()).toList(),
};
}
// 系统主题
class SystemTheme {
final String themeName;
final bool isDark;
final String? primaryColor;
final String? accentColor;
SystemTheme({
required this.themeName,
required this.isDark,
this.primaryColor,
this.accentColor,
});
}跨平台桌面桥接
1. 统一桌面 API
// 统一桌面API桥接
class DesktopAPIBridge {
static final Map<String, DesktopAPIBridge> _instances = {};
late final WindowsAPIBridge _windows;
late final MacOSAPIBridge _macos;
late final LinuxAPIBridge _linux;
late final String _currentPlatform;
// 获取平台实例
factory DesktopAPIBridge.getInstance() {
final platform = Platform.operatingSystem;
if (!_instances.containsKey(platform)) {
_instances[platform] = DesktopAPIBridge._internal(platform);
}
return _instances[platform]!;
}
DesktopAPIBridge._internal(this._currentPlatform) {
_windows = WindowsAPIBridge();
_macos = MacOSAPIBridge();
_linux = LinuxAPIBridge();
}
// 获取系统信息
Future<Map<String, dynamic>> getSystemInfo() async {
switch (_currentPlatform) {
case 'windows':
return await _windows.getSystemInfo();
case 'macos':
return await _macos.getSystemInfo();
case 'linux':
return await _linux.getSystemInfo();
default:
throw UnsupportedError('Platform not supported: $_currentPlatform');
}
}
// 显示通知
Future<void> showNotification({
required String title,
required String body,
String? iconPath,
}) async {
switch (_currentPlatform) {
case 'windows':
await _windows.showNotification(title: title, body: body, iconPath: iconPath);
break;
case 'macos':
await _macos.showNotification(title: title, subtitle: '', body: body);
break;
case 'linux':
await _linux.showNotification(title: title, body: body, iconPath: iconPath);
break;
default:
throw UnsupportedError('Platform not supported: $_currentPlatform');
}
}
// 显示文件选择器
Future<String?> showFilePicker({
String? initialDirectory,
String? filter,
bool allowMultiple = false,
}) async {
switch (_currentPlatform) {
case 'windows':
return await _windows.showFilePicker(
initialDirectory: initialDirectory,
filter: filter,
allowMultiple: allowMultiple,
);
case 'macos':
// macOS实现
return await _showMacOSFilePicker(
initialDirectory: initialDirectory,
filter: filter,
allowMultiple: allowMultiple,
);
case 'linux':
// Linux实现
return await _showLinuxFilePicker(
initialDirectory: initialDirectory,
filter: filter,
allowMultiple: allowMultiple,
);
default:
throw UnsupportedError('Platform not supported: $_currentPlatform');
}
}
// macOS文件选择器实现
Future<String?> _showMacOSFilePicker({
String? initialDirectory,
String? filter,
bool allowMultiple = false,
}) async {
// 实现macOS文件选择器逻辑
return null;
}
// Linux文件选择器实现
Future<String?> _showLinuxFilePicker({
String? initialDirectory,
String? filter,
bool allowMultiple = false,
}) async {
// 实现Linux文件选择器逻辑
return null;
}
}2. 桌面应用生命周期管理
// 桌面应用生命周期管理器
class DesktopLifecycleManager {
static const MethodChannel _channel = MethodChannel('desktop_lifecycle');
static final List<Function()> _onResumeCallbacks = [];
static final List<Function()> _onPauseCallbacks = [];
static final List<Function()> _onTerminateCallbacks = [];
// 初始化生命周期管理
static void initialize() {
_channel.setMethodCallHandler(_handleLifecycleEvent);
}
// 处理生命周期事件
static Future<dynamic> _handleLifecycleEvent(MethodCall call) async {
switch (call.method) {
case 'onResume':
for (final callback in _onResumeCallbacks) {
callback();
}
break;
case 'onPause':
for (final callback in _onPauseCallbacks) {
callback();
}
break;
case 'onTerminate':
for (final callback in _onTerminateCallbacks) {
callback();
}
break;
}
}
// 注册生命周期回调
static void addOnResumeCallback(Function() callback) {
_onResumeCallbacks.add(callback);
}
static void addOnPauseCallback(Function() callback) {
_onPauseCallbacks.add(callback);
}
static void addOnTerminateCallback(Function() callback) {
_onTerminateCallbacks.add(callback);
}
// 移除生命周期回调
static void removeOnResumeCallback(Function() callback) {
_onResumeCallbacks.remove(callback);
}
static void removeOnPauseCallback(Function() callback) {
_onPauseCallbacks.remove(callback);
}
static void removeOnTerminateCallback(Function() callback) {
_onTerminateCallbacks.remove(callback);
}
// 请求应用退出
static Future<void> requestExit() async {
try {
await _channel.invokeMethod('requestExit');
} on PlatformException catch (e) {
throw Exception('Failed to request exit: ${e.message}');
}
}
// 防止应用退出
static Future<void> preventExit() async {
try {
await _channel.invokeMethod('preventExit');
} on PlatformException catch (e) {
throw Exception('Failed to prevent exit: ${e.message}');
}
}
}性能优化
1. 资源管理
// 桌面资源管理器
class DesktopResourceManager {
static final Map<String, dynamic> _resources = {};
static Timer? _cleanupTimer;
// 初始化资源管理
static void initialize() {
_cleanupTimer = Timer.periodic(Duration(minutes: 5), (_) => _cleanup());
}
// 注册资源
static void registerResource(String key, dynamic resource) {
_resources[key] = resource;
}
// 获取资源
static T? getResource<T>(String key) {
return _resources[key] as T?;
}
// 释放资源
static void releaseResource(String key) {
final resource = _resources.remove(key);
if (resource != null) {
_disposeResource(resource);
}
}
// 清理资源
static void _cleanup() {
final expiredKeys = <String>[];
_resources.forEach((key, resource) {
if (_isResourceExpired(resource)) {
expiredKeys.add(key);
}
});
for (final key in expiredKeys) {
releaseResource(key);
}
}
// 释放单个资源
static void _disposeResource(dynamic resource) {
// 根据资源类型进行不同的释放操作
if (resource is StreamSubscription) {
resource.cancel();
} else if (resource is Timer) {
resource.cancel();
}
// 其他资源类型的释放逻辑
}
// 检查资源是否过期
static bool _isResourceExpired(dynamic resource) {
// 实现资源过期检查逻辑
return false;
}
// 释放所有资源
static void disposeAll() {
_cleanupTimer?.cancel();
_resources.forEach((key, resource) {
_disposeResource(resource);
});
_resources.clear();
}
}2. 性能监控
// 桌面性能监控器
class DesktopPerformanceMonitor {
static final Map<String, Stopwatch> _timers = {};
static final List<PerformanceMetric> _metrics = [];
// 开始性能计时
static void startTimer(String name) {
_timers[name] = Stopwatch()..start();
}
// 结束性能计时
static Duration endTimer(String name) {
final timer = _timers.remove(name);
if (timer != null) {
timer.stop();
_addMetric(name, timer.elapsed);
return timer.elapsed;
}
return Duration.zero;
}
// 添加性能指标
static void _addMetric(String name, Duration duration) {
_metrics.add(PerformanceMetric(
name: name,
duration: duration,
timestamp: DateTime.now(),
));
// 保持最近1000条记录
if (_metrics.length > 1000) {
_metrics.removeAt(0);
}
}
// 获取性能指标
static List<PerformanceMetric> getMetrics({String? name}) {
if (name != null) {
return _metrics.where((metric) => metric.name == name).toList();
}
return List.from(_metrics);
}
// 获取平均性能
static Duration getAveragePerformance(String name) {
final nameMetrics = _metrics.where((metric) => metric.name == name);
if (nameMetrics.isEmpty) return Duration.zero;
final totalMicroseconds = nameMetrics
.map((metric) => metric.duration.inMicroseconds)
.reduce((a, b) => a + b);
return Duration(microseconds: totalMicroseconds ~/ nameMetrics.length);
}
// 清除性能指标
static void clearMetrics() {
_metrics.clear();
}
}
// 性能指标
class PerformanceMetric {
final String name;
final Duration duration;
final DateTime timestamp;
PerformanceMetric({
required this.name,
required this.duration,
required this.timestamp,
});
}最佳实践
1. 架构设计
- 平台抽象：创建统一的平台抽象层，隐藏平台差异
- 模块化设计：按功能模块组织代码，提高可维护性
- 依赖注入：使用依赖注入管理平台特定实现
- 错误处理：建立完善的错误处理和恢复机制
2. 开发建议
- 平台特性利用：充分利用各平台的独特特性
- 用户体验一致性：保持跨平台用户体验的一致性
- 性能优化：针对桌面环境进行性能优化
- 可访问性：遵循桌面应用可访问性标准
3. 部署与分发
- 打包优化：优化应用包大小和启动时间
- 自动更新：实现自动更新机制
- 签名验证：确保应用安全性和完整性
- 多渠道分发：支持多种分发渠道
实战案例：Windows 桌面应用的三件套
我在 flutter_brightness 里完整走了一遍 Windows 桌面桥接。这个应用常驻后台，根据串口光照传感器自动调屏幕亮度。做桌面应用，绕不开三件事：窗口管理、系统托盘、开机自启。
窗口管理用 window_manager。桌面应用和手机 App 最大的区别是用户会最小化、拖边框、关窗口。我当时的需求是：点关闭按钮不退出，只最小化到托盘（参考 QQ/微信的逻辑）：
// 核心思路：拦截窗口关闭事件，转为隐藏到托盘
// window_manager 提供了 windowManager.setPreventClose(true)
// 然后在 onWindowClose 回调里调 windowManager.hide()系统托盘用 system_tray。托盘图标 + 右键菜单（显示主窗口 / 开机自启开关 / 退出）是桌面应用的标配。坑点：Windows 上托盘图标的 ico 格式有尺寸要求，我第一次随便找了张 png 转的，托盘里显示出来是糊的——后来老老实实按 16x16 / 32x32 做了两套。
调系统亮度用 win32 包直接调 Windows API。这是真正的”桥接”：Dart 层没有屏幕亮度 API，必须走 FFI 调 dxva2.dll / WmiMonitorBrightnessMethods。win32 包把这些都包好了，但记住它和 ffi 版本是强绑定的（见 FFI 那篇）。
开机自启我自己写了个 AutostartService，往注册表 HKCU\Software\Microsoft\Windows\CurrentVersion\Run 写键值。为什么不用插件？因为就三行注册表操作，引入一个插件反而多一层不确定性——桌面端 bridge 的原则是：系统 API 一步到位能搞定的，别绕。
这个项目的 pubspec.yaml 里桌面相关的就是这几个：window_manager: ^0.3.7、system_tray、win32、ffi、flutter_libserialport。没有用任何”跨平台桌面框架”，Windows 先跑通再说——我的用户 100% 是 Windows，这也是实战和教程最大的不同：教程教你兼容三个平台，实战只做目标用户在用的那个。
总结
Flutter 与桌面平台桥接技术为构建跨平台桌面应用提供了强大的支持。通过掌握 Windows、macOS 和 Linux 平台的桥接技术，开发者可以构建出功能丰富、用户体验优秀的桌面应用。
关键成功因素：
- 深入理解各桌面平台特性
- 合理设计平台抽象层
- 重视性能优化
- 确保用户体验一致性
- 建立完善的测试体系
通过本文的学习，开发者应该能够充分利用 Flutter 桌面平台桥接技术，构建出高质量的跨平台桌面应用。