Flutter 中如何进行桌面应用的系统集成？-JavaScript中文网-JavaScript教程资源分享门户

推荐答案

在 Flutter 中进行桌面应用的系统集成，可以通过以下步骤实现：

使用 flutter create 创建项目：

flutter create my_desktop_app
cd my_desktop_app

启用桌面支持：

对于 Windows：
```
flutter config --enable-windows-desktop
```
对于 macOS：
```
flutter config --enable-macos-desktop
```
对于 Linux：
```
flutter config --enable-linux-desktop
```

运行桌面应用：
- 对于 Windows：
```
flutter run -d windows
```
- 对于 macOS：
```
flutter run -d macos
```
- 对于 Linux：
```
flutter run -d linux
```

使用平台通道（Platform Channels）进行系统集成：

在 lib/main.dart 中定义平台通道：

// www.javascriptcn.com code example
import 'package:flutter/services.dart';

class SystemIntegration {
  static const platform = MethodChannel('com.example.system_integration');

  Future<String> getSystemInfo() async {
    try {
      final String result = await platform.invokeMethod('getSystemInfo');
      return result;
    } on PlatformException catch (e) {
      return "Failed to get system info: '${e.message}'.";
    }
  }
}

在桌面平台的代码中实现平台通道：

Windows (windows/runner/main.cpp):

// www.javascriptcn.com code example
#include <flutter/method_channel.h>
#include <flutter/plugin_registrar_windows.h>
#include <flutter/standard_method_codec.h>

class SystemIntegrationPlugin : public flutter::Plugin {
public:
    static void RegisterWithRegistrar(flutter::PluginRegistrarWindows *registrar);

    SystemIntegrationPlugin();

    virtual ~SystemIntegrationPlugin();

private:
    void HandleMethodCall(
        const flutter::MethodCall<flutter::EncodableValue> &method_call,
        std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result);
};

void SystemIntegrationPlugin::RegisterWithRegistrar(
    flutter::PluginRegistrarWindows *registrar) {
    auto channel =
        std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
            registrar->messenger(), "com.example.system_integration",
            &flutter::StandardMethodCodec::GetInstance());

    auto plugin = std::make_unique<SystemIntegrationPlugin>();

    channel->SetMethodCallHandler(
        [plugin_pointer = plugin.get()](const auto &call, auto result) {
            plugin_pointer->HandleMethodCall(call, std::move(result));
        });

    registrar->AddPlugin(std::move(plugin));
}

SystemIntegrationPlugin::SystemIntegrationPlugin() {}

SystemIntegrationPlugin::~SystemIntegrationPlugin() {}

void SystemIntegrationPlugin::HandleMethodCall(
    const flutter::MethodCall<flutter::EncodableValue> &method_call,
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
    if (method_call.method_name().compare("getSystemInfo") == 0) {
        result->Success(flutter::EncodableValue("Windows System Info"));
    } else {
        result->NotImplemented();
    }
}

macOS (macos/Runner/AppDelegate.swift):

// www.javascriptcn.com code example
import Cocoa
import FlutterMacOS

@NSApplicationMain
class AppDelegate: FlutterAppDelegate {
    override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
        return true
    }

    override func applicationDidFinishLaunching(_ aNotification: Notification) {
        let controller = self.window.contentViewController as! FlutterViewController
        let systemChannel = FlutterMethodChannel(name: "com.example.system_integration",
                                                binaryMessenger: controller.engine.binaryMessenger)
        systemChannel.setMethodCallHandler({
            (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
            if call.method == "getSystemInfo" {
                result("macOS System Info")
            } else {
                result(FlutterMethodNotImplemented)
            }
        })
    }
}

Linux (linux/my_application.cc):

// www.javascriptcn.com code example
#include <flutter_linux/flutter_linux.h>
#include <gtk/gtk.h>

static void system_channel_method_call_cb(FlMethodChannel* channel,
                                          FlMethodCall* method_call,
                                          gpointer user_data) {
    g_autoptr(FlMethodResponse) response = nullptr;
    if (strcmp(fl_method_call_get_name(method_call), "getSystemInfo") == 0) {
        response = FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_string("Linux System Info")));
    } else {
        response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
    }
    fl_method_call_respond(method_call, response, nullptr);
}

static void system_channel_created_cb(FlEngine* engine, gpointer user_data) {
    g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
    g_autoptr(FlMethodChannel) channel =
        fl_method_channel_new(fl_engine_get_binary_messenger(engine),
                              "com.example.system_integration",
                              FL_METHOD_CODEC(codec));
    fl_method_channel_set_method_call_handler(channel, system_channel_method_call_cb, nullptr, nullptr);
}

int main(int argc, char** argv) {
    gtk_init(&argc, &argv);

    g_autoptr(MyApplication) app = my_application_new();
    g_signal_connect(app, "engine-created", G_CALLBACK(system_channel_created_cb), nullptr);
    return g_application_run(G_APPLICATION(app), argc, argv);
}

本题详细解读

1. 创建 Flutter 桌面项目

首先，使用 flutter create 命令创建一个新的 Flutter 项目。然后，通过 flutter config 命令启用对特定桌面平台的支持。

2. 运行桌面应用

启用桌面支持后，可以使用 flutter run 命令在指定的桌面平台上运行应用。Flutter 会自动生成相应的桌面平台代码，并启动应用。

3. 使用平台通道进行系统集成

Flutter 提供了平台通道（Platform Channels）机制，允许 Dart 代码与平台原生代码进行通信。通过定义平台通道，可以在 Flutter 中调用平台特定的功能。

Dart 端：在 Dart 代码中定义平台通道，并通过 MethodChannel 调用平台方法。
平台端：在桌面平台的代码中实现平台通道的处理逻辑，响应 Dart 端的调用。

4. 平台通道的实现

在桌面平台的代码中，需要实现平台通道的处理逻辑。不同的桌面平台（Windows、macOS、Linux）有不同的实现方式：

Windows：使用 C++ 编写平台通道的处理逻辑，并通过 MethodChannel 与 Dart 端通信。
macOS：使用 Swift 编写平台通道的处理逻辑，并通过 FlutterMethodChannel 与 Dart 端通信。
Linux：使用 C 编写平台通道的处理逻辑，并通过 FlMethodChannel 与 Dart 端通信。

通过这种方式，Flutter 桌面应用可以实现与操作系统的深度集成，调用系统级别的功能。