编写自定义平台相关代码

本指南介绍了如何在 Flutter 中使用自定义平台相关代码。

你可以在 Flutter 应用中使用平台相关代码。几种常见的方法包括：

• 使用 Flutter 的平台通道 API 在 Flutter 和目标平台之间传递消息。有关更多信息，请参阅 使用平台通道调用平台相关代码。

• 使用 Pigeon 软件包生成类型安全的平台相关代码。有关更多信息，请参阅 使用 Pigeon 软件包调用平台相关代码。

Flutter 支持以下平台及对应的平台相关语言：

• Android：Kotlin, Java
• iOS：Swift, Objective-C
• Windows：C++
• macOS：Objective-C
• Linux：C

如下图所示，消息通过平台通道在客户端（UI）和宿主（平台）之间传递：

在上图中，消息和响应通过通道异步传递，以确保用户界面保持响应。在客户端，用于 Flutter 的 MethodChannel 支持发送对应于方法调用的消息。在平台侧，用于 Android 的 MethodChannel 和 用于 iOS 的 FlutterMethodChannel 支持接收方法调用并返回结果。这些类使你能够以极少的样板代码开发平台插件。

标准的平台通道 API 和 Pigeon 软件包使用一种名为 StandardMessageCodec 的标准消息编解码器，它支持对类似于 JSON 的简单值进行高效的二进制序列化，例如布尔值、数字、字符串、字节缓冲区、列表和映射。当你发送和接收这些值时，消息的序列化和反序列化会自动发生。

下表显示了 Dart 值在平台侧的对应关系（反之亦然）：

以下代码演示了如何调用平台相关 API 来获取并显示当前的电池电量。它使用 Android 的 BatteryManager API、iOS 的 device.batteryLevel API、Windows 的 GetSystemPowerStatus API 以及 Linux 的 UPower API，通过单一平台消息 getBatteryLevel() 来实现。

此示例将平台相关代码直接添加在主应用中。如果你希望在多个应用中复用平台相关代码，项目创建步骤会有所不同（请参阅 开发软件包），但平台通道代码的编写方式是一样的。

首先创建一个新应用

• 在终端中运行：flutter create batterylevel

默认情况下，我们的模板支持使用 Kotlin 编写 Android 代码，或使用 Swift 编写 iOS 代码。如需使用 Java 或 Objective-C，请使用 -i 和/或 -a 标志：

• 在终端中运行：flutter create -i objc -a java batterylevel

应用的 State 类持有当前应用的状态。扩展该类以保存当前的电池状态。

首先，构建通道。使用一个带有单一平台方法的 MethodChannel，该方法返回电池电量。

通道的客户端和宿主端通过通道构造函数中传递的通道名称连接。在单个应用中使用的所有通道名称必须唯一；请为通道名称添加唯一的“域前缀”，例如：samples.flutter.dev/battery。

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

class _MyHomePageState extends State<MyHomePage> {
  static const platform = MethodChannel('samples.flutter.dev/battery');
  // Get battery level.

接下来，在方法通道上调用一个方法，使用 String 标识符 getBatteryLevel 指定要调用的具体方法。调用可能会失败（例如，如果平台不支持该平台 API，如在模拟器中运行时），因此请将 invokeMethod 调用包装在 try-catch 语句中。

使用返回的结果在 setState 内部更新 _batteryLevel 以更新用户界面状态。

// Get battery level.
String _batteryLevel = 'Unknown battery level.';
​
Future<void> _getBatteryLevel() async {
  String batteryLevel;
  try {
    final result = await platform.invokeMethod<int>('getBatteryLevel');
    batteryLevel = 'Battery level at $result % .';
  } on PlatformException catch (e) {
    batteryLevel = "Failed to get battery level: '${e.message}'.";
  }
​
  setState(() {
    _batteryLevel = batteryLevel;
  });
}

最后，替换模板中的 build 方法，使其包含一个简单的用户界面，显示电池电量字符串，并提供一个刷新该值的按钮。

@override
Widget build(BuildContext context) {
  return Material(
    child: Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: [
          ElevatedButton(
            onPressed: _getBatteryLevel,
            child: const Text('Get Battery Level'),
          ),
          Text(_batteryLevel),
        ],
      ),
    ),
  );
}

import androidx.annotation.NonNull
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel
​
class MainActivity: FlutterActivity() {
  private val CHANNEL = "samples.flutter.dev/battery"
​
  override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
      call, result ->
      // This method is invoked on the main thread.
      // TODO
    }
  }
}

import android.content.Context
import android.content.ContextWrapper
import android.content.Intent
import android.content.IntentFilter
import android.os.BatteryManager
import android.os.Build.VERSION
import android.os.Build.VERSION_CODES

  private fun getBatteryLevel(): Int {
    val batteryLevel: Int
    if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
      val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
      batteryLevel = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
    } else {
      val intent = ContextWrapper(applicationContext).registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
      batteryLevel = intent!!.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) * 100 / intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
    }
​
    return batteryLevel
  }

    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
      call, result ->
      // This method is invoked on the main thread.
      // TODO
    }

    MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
      // This method is invoked on the main thread.
      call, result ->
      if (call.method == "getBatteryLevel") {
        val batteryLevel = getBatteryLevel()
​
        if (batteryLevel != -1) {
          result.success(batteryLevel)
        } else {
          result.error("UNAVAILABLE", "Battery level not available.", null)
        }
      } else {
        result.notImplemented()
      }
    }

import androidx.annotation.NonNull;
import io.flutter.embedding.android.FlutterActivity;
import io.flutter.embedding.engine.FlutterEngine;
import io.flutter.plugin.common.MethodChannel;
​
public class MainActivity extends FlutterActivity {
  private static final String CHANNEL = "samples.flutter.dev/battery";
​
  @Override
  public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
    super.configureFlutterEngine(flutterEngine);
    new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
        .setMethodCallHandler(
          (call, result) -> {
            // This method is invoked on the main thread.
            // TODO
          }
        );
  }
}

import android.content.ContextWrapper;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.os.Bundle;

  private int getBatteryLevel() {
    int batteryLevel = -1;
    if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
      BatteryManager batteryManager = (BatteryManager) getSystemService(BATTERY_SERVICE);
      batteryLevel = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY);
    } else {
      Intent intent = new ContextWrapper(getApplicationContext()).
          registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
      batteryLevel = (intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) * 100) /
          intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
    }
​
    return batteryLevel;
  }

      new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
        .setMethodCallHandler(
          (call, result) -> {
            // This method is invoked on the main thread.
            // TODO
          }
      );

      new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
        .setMethodCallHandler(
          (call, result) -> {
            // This method is invoked on the main thread.
            if (call.method.equals("getBatteryLevel")) {
              int batteryLevel = getBatteryLevel();
​
              if (batteryLevel != -1) {
                result.success(batteryLevel);
              } else {
                result.error("UNAVAILABLE", "Battery level not available.", null);
              }
            } else {
              result.notImplemented();
            }
          }
      );

现在你应该能够在 Android 上运行该应用了。如果使用 Android 模拟器，请在工具栏 ... 按钮中打开的“扩展控件 (Extended Controls)”面板中设置电池电量。

@main
@objc class AppDelegate: FlutterAppDelegate, FlutterImplicitEngineDelegate {
​
  func didInitializeImplicitFlutterEngine(_ engineBridge: FlutterImplicitEngineBridge) {
    GeneratedPluginRegistrant.register(with: engineBridge.pluginRegistry)
​
    let batteryChannel = FlutterMethodChannel(
      name: "samples.flutter.dev/battery",
      binaryMessenger: engineBridge.applicationRegistrar.messenger()
    )
​
    batteryChannel.setMethodCallHandler({
      [weak self] (call: FlutterMethodCall, result: FlutterResult) -> Void in
      // This method is invoked on the UI thread.
      // Handle battery messages.
    })
  }
}

private func receiveBatteryLevel(result: FlutterResult) {
  let device = UIDevice.current
  device.isBatteryMonitoringEnabled = true
  if device.batteryState == UIDevice.BatteryState.unknown {
    result(FlutterError(code: "UNAVAILABLE",
                        message: "Battery level not available.",
                        details: nil))
  } else {
    result(Int(device.batteryLevel * 100))
  }
}

batteryChannel.setMethodCallHandler({
  [weak self] (call: FlutterMethodCall, result: FlutterResult) -> Void in
  // This method is invoked on the UI thread.
  guard call.method == "getBatteryLevel" else {
    result(FlutterMethodNotImplemented)
    return
  }
  self?.receiveBatteryLevel(result: result)
})

#import <Flutter/Flutter.h>
#import "GeneratedPluginRegistrant.h"
​
@implementation AppDelegate
​
- (void)didInitializeImplicitFlutterEngine:(NSObject<FlutterImplicitEngineBridge>*)engineBridge {
  [GeneratedPluginRegistrant registerWithRegistry:engineBridge.pluginRegistry];
​
  FlutterMethodChannel* batteryChannel = [FlutterMethodChannel
                                        methodChannelWithName:@"samples.flutter.dev/battery"
                                        binaryMessenger:engineBridge.applicationRegistrar.messenger];
​
  [batteryChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
    // This method is invoked on the UI thread.
    // TODO
  }];
}
@end

- (int)getBatteryLevel {
  UIDevice* device = UIDevice.currentDevice;
  device.batteryMonitoringEnabled = YES;
  if (device.batteryState == UIDeviceBatteryStateUnknown) {
    return -1;
  } else {
    return (int)(device.batteryLevel * 100);
  }
}

__weak typeof(self) weakSelf = self;
[batteryChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
  // This method is invoked on the UI thread.
  if ([@"getBatteryLevel" isEqualToString:call.method]) {
    int batteryLevel = [weakSelf getBatteryLevel];
​
    if (batteryLevel == -1) {
      result([FlutterError errorWithCode:@"UNAVAILABLE"
                                 message:@"Battery level not available."
                                 details:nil]);
    } else {
      result(@(batteryLevel));
    }
  } else {
    result(FlutterMethodNotImplemented);
  }
}];

现在你应该能够在 iOS 上运行该应用了。注意，iOS 模拟器不支持电池 API，应用会显示“Battery level not available”。

首先在 Visual Studio 中打开 Flutter 应用的 Windows 宿主部分

1. 在项目目录中运行 flutter build windows 一次，以生成 Visual Studio 解决方案文件。

2. 启动 Visual Studio。

3. 选择 Open a project or solution。

4. 导航至存放 Flutter 应用的目录，进入 build 文件夹，再进入 windows 文件夹，选中 batterylevel.sln 文件。点击 Open。

添加平台通道方法的 C++ 实现

1. 在解决方案资源管理器中展开 batterylevel > Source Files。

2. 打开 flutter_window.cpp 文件。

首先，在文件顶部，即 #include "flutter_window.h" 之后，添加必要的包含文件。

#include <flutter/event_channel.h>
#include <flutter/event_sink.h>
#include <flutter/event_stream_handler_functions.h>
#include <flutter/method_channel.h>
#include <flutter/standard_method_codec.h>
#include <windows.h>
​
#include <memory>

编辑 FlutterWindow::OnCreate 方法，创建一个绑定到 samples.flutter.dev/battery 通道名称的 flutter::MethodChannel。

bool FlutterWindow::OnCreate() {
  // ...
  RegisterPlugins(flutter_controller_->engine());
​
  flutter::MethodChannel<> channel(
      flutter_controller_->engine()->messenger(), "samples.flutter.dev/battery",
      &flutter::StandardMethodCodec::GetInstance());
  channel.SetMethodCallHandler(
      [](const flutter::MethodCall<>& call,
         std::unique_ptr<flutter::MethodResult<>> result) {
        // TODO
      });
​
  SetChildContent(flutter_controller_->view()->GetNativeWindow());
  return true;
}

接下来，添加使用 Windows 电池 API 获取电池电量的 C++ 代码。这段代码与你在原生 Windows 应用中编写的代码完全相同。

在 flutter_window.cpp 的 #include 部分之后添加以下函数。

static int GetBatteryLevel() {
  SYSTEM_POWER_STATUS status;
  if (GetSystemPowerStatus(&status) == 0 || status.BatteryLifePercent == 255) {
    return -1;
  }
  return status.BatteryLifePercent;
}

最后，补全之前添加的 setMethodCallHandler() 方法。你需要处理单一平台方法 getBatteryLevel()，因此在 call 参数中进行测试。此平台方法的实现调用了上一步编写的 Windows 代码。如果调用了未知方法，则进行相应报告。

移除以下代码

  channel.SetMethodCallHandler(
      [](const flutter::MethodCall<>& call,
         std::unique_ptr<flutter::MethodResult<>> result) {
        // TODO
      });

并替换为以下内容

  channel.SetMethodCallHandler(
      [](const flutter::MethodCall<>& call,
         std::unique_ptr<flutter::MethodResult<>> result) {
        if (call.method_name() == "getBatteryLevel") {
          int battery_level = GetBatteryLevel();
          if (battery_level != -1) {
            result->Success(battery_level);
          } else {
            result->Error("UNAVAILABLE", "Battery level not available.");
          }
        } else {
          result->NotImplemented();
        }
      });

现在你应该能够在 Windows 上运行该应用了。如果你的设备没有电池，它会显示“Battery level not available”。

首先在 Xcode 中打开 Flutter 应用的 macOS 宿主部分

1. 启动 Xcode。

2. 选择菜单项 File > Open...。

3. 导航至存放 Flutter 应用的目录，选择其中的 macos 文件夹。点击 OK。

添加平台通道方法的 Swift 实现

1. 在项目导航器中展开 Runner > Runner。

2. 在项目导航器的 Runner > Runner 下打开 MainFlutterWindow.swift 文件。

首先，在文件顶部，即 import FlutterMacOS 之后，添加必要的导入。

import IOKit.ps

在 awakeFromNib 方法中创建一个绑定到 samples.flutter.dev/battery 通道名称的 FlutterMethodChannel。

  override func awakeFromNib() {
    // ...
    self.setFrame(windowFrame, display: true)
​
    let batteryChannel = FlutterMethodChannel(
      name: "samples.flutter.dev/battery",
      binaryMessenger: flutterViewController.engine.binaryMessenger)
    batteryChannel.setMethodCallHandler { (call, result) in
      // This method is invoked on the UI thread.
      // Handle battery messages.
    }
​
    RegisterGeneratedPlugins(registry: flutterViewController)
​
    super.awakeFromNib()
  }
}

接下来，添加使用 IOKit 电池 API 获取电池电量的 macOS Swift 代码。这段代码与你在原生 macOS 应用中编写的代码完全相同。

将以下内容作为新方法添加到 MainFlutterWindow.swift 的底部。

private func getBatteryLevel() -> Int? {
  let info = IOPSCopyPowerSourcesInfo().takeRetainedValue()
  let sources: Array<CFTypeRef> = IOPSCopyPowerSourcesList(info).takeRetainedValue() as Array
  if let source = sources.first {
    let description =
      IOPSGetPowerSourceDescription(info, source).takeUnretainedValue() as! [String: AnyObject]
    if let level = description[kIOPSCurrentCapacityKey] as? Int {
      return level
    }
  }
  return nil
}

最后，补全之前添加的 setMethodCallHandler 方法。你需要处理单一平台方法 getBatteryLevel()，因此在 call 参数中进行测试。此平台方法的实现调用了上一步编写的 macOS 代码。如果调用了未知方法，则进行相应报告。

batteryChannel.setMethodCallHandler { (call, result) in
  switch call.method {
  case "getBatteryLevel":
    guard let level = getBatteryLevel() else {
      result(
        FlutterError(
          code: "UNAVAILABLE",
          message: "Battery level not available",
          details: nil))
     return
    }
    result(level)
  default:
    result(FlutterMethodNotImplemented)
  }
}

现在你应该能够在 macOS 上运行该应用了。如果你的设备没有电池，它会显示“Battery level not available”。

对于此示例，你需要安装 upower 开发头文件。这通常可以从你的发行版获取，例如：

sudo apt install libupower-glib-dev

首先在选定的编辑器中打开 Flutter 应用的 Linux 宿主部分。以下说明适用于安装了 "C/C++" 和 "CMake" 扩展的 Visual Studio Code，但也可以适配其他 IDE。

1. 启动 Visual Studio Code。

2. 打开项目内的 linux 目录。

3. 在提示 Would you like to configure project "linux"? 时选择 Yes。这将启用 C++ 自动补全。

4. 打开 runner/my_application.cc 文件。

首先，在文件顶部，即 #include <flutter_linux/flutter_linux.h> 之后，添加必要的包含文件。

#include <math.h>
#include <upower.h>

在 _MyApplication 结构体中添加一个 FlMethodChannel。

struct _MyApplication {
  GtkApplication parent_instance;
  char** dart_entrypoint_arguments;
  FlMethodChannel* battery_channel;
};

确保在 my_application_dispose 中进行清理。

static void my_application_dispose(GObject* object) {
  MyApplication* self = MY_APPLICATION(object);
  g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
  g_clear_object(&self->battery_channel);
  G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
}

编辑 my_application_activate 方法，并在 fl_register_plugins 调用之后初始化使用通道名称 samples.flutter.dev/battery 的 battery_channel。

static void my_application_activate(GApplication* application) {
  // ...
  fl_register_plugins(FL_PLUGIN_REGISTRY(self->view));
​
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  self->battery_channel = fl_method_channel_new(
      fl_engine_get_binary_messenger(fl_view_get_engine(view)),
      "samples.flutter.dev/battery", FL_METHOD_CODEC(codec));
  fl_method_channel_set_method_call_handler(
      self->battery_channel, battery_method_call_handler, self, nullptr);
​
  gtk_widget_grab_focus(GTK_WIDGET(self->view));
}

接下来，添加使用 Linux 电池 API 获取电池电量的 C 代码。这段代码与你在原生 Linux 应用中编写的代码完全相同。

在 my_application.cc 的 G_DEFINE_TYPE 行之后添加以下函数。

static FlMethodResponse* get_battery_level() {
  // Find the first available battery and report that.
  g_autoptr(UpClient) up_client = up_client_new();
  g_autoptr(GPtrArray) devices = up_client_get_devices2(up_client);
  if (devices->len == 0) {
    return FL_METHOD_RESPONSE(fl_method_error_response_new(
        "UNAVAILABLE", "Device does not have a battery.", nullptr));
  }
​
  UpDevice* device = UP_DEVICE(g_ptr_array_index(devices, 0));
  double percentage = 0;
  g_object_get(device, "percentage", &percentage, nullptr);
​
  g_autoptr(FlValue) result =
      fl_value_new_int(static_cast<int64_t>(round(percentage)));
  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
}

最后，添加之前在 fl_method_channel_set_method_call_handler 调用中引用的 battery_method_call_handler 函数。你需要处理单一平台方法 getBatteryLevel，因此在 method_call 参数中进行测试。此函数的实现调用了上一步编写的 Linux 代码。如果调用了未知方法，则进行相应报告。

在 get_battery_level 函数后添加以下代码。

static void battery_method_call_handler(FlMethodChannel* channel,
                                        FlMethodCall* method_call,
                                        gpointer user_data) {
  g_autoptr(FlMethodResponse) response = nullptr;
  if (strcmp(fl_method_call_get_name(method_call), "getBatteryLevel") == 0) {
    response = get_battery_level();
  } else {
    response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
  }
​
  g_autoptr(GError) error = nullptr;
  if (!fl_method_call_respond(method_call, response, &error)) {
    g_warning("Failed to send response: %s", error->message);
  }
}

现在你应该能够在 Linux 上运行该应用了。如果你的设备没有电池，它会显示“Battery level not available”。

你可以使用 Pigeon 软件包作为 Flutter 平台通道 API 的替代方案，以生成能够以结构化、类型安全的方式发送消息的代码。Pigeon 的工作流程如下：

• Flutter 应用通过平台通道向其宿主（即应用的非 Dart 部分）发送结构化的、类型安全的消息。

• 宿主监听该平台通道并接收消息。然后，它使用原生编程语言调用任意数量的平台相关 API，并将响应发送回客户端（即应用的 Flutter 部分）。

使用此软件包消除了在宿主和客户端之间匹配消息名称和数据类型字符串的需要。它支持嵌套类、将消息分组到 API 中、生成异步包装代码以及在两个方向上发送消息。生成的代码易于阅读，并能保证不同版本的多个客户端之间不会产生冲突。

使用 Pigeon 时，消息传递协议定义在 Dart 的一个子集中，然后为 Android、iOS、macOS 或 Windows 生成消息传递代码。例如：

import 'package:pigeon/pigeon.dart';
​
class SearchRequest {
  final String query;
​
  SearchRequest({required this.query});
}
​
class SearchReply {
  final String result;
​
  SearchReply({required this.result});
}
​
@HostApi()
abstract class Api {
  @async
  SearchReply search(SearchRequest request);
}

import 'generated_pigeon.dart';
​
Future<void> onClick() async {
  SearchRequest request = SearchRequest(query: 'test');
  Api api = SomeApi();
  SearchReply reply = await api.search(request);
  print('reply: ${reply.result}');
}

你可以在 pub.dev 上的 pigeon 页面找到完整的示例和更多信息。

当在平台侧调用指向 Flutter 的通道时，请在平台的**主线程**上进行调用。当在 Flutter 中调用指向平台侧的通道时，你可以从作为根 Isolate 的任意 Isolate 或已注册为后台 Isolate 的 Isolate 中调用。平台侧的处理器可以在平台的主线程执行，或者如果使用任务队列（Task Queue），也可以在后台线程执行。你可以异步并在任何线程上调用平台侧的处理器。

插件和通道可以由任何 Isolate 使用，但该 Isolate 必须是根 Isolate（由 Flutter 创建的那个），或者为根 Isolate 注册的后台 Isolate。

以下示例展示了如何注册后台 Isolate，以便从后台 Isolate 中使用插件。

import 'package:flutter/services.dart';
import 'package:shared_preferences/shared_preferences.dart';
​
void _isolateMain(RootIsolateToken rootIsolateToken) async {
  BackgroundIsolateBinaryMessenger.ensureInitialized(rootIsolateToken);
  SharedPreferences sharedPreferences = await SharedPreferences.getInstance();
  print(sharedPreferences.getBool('isDebug'));
}
​
void main() {
  RootIsolateToken rootIsolateToken = RootIsolateToken.instance!;
  Isolate.spawn(_isolateMain, rootIsolateToken);
}

为了让通道的平台侧处理器在 Android 应用的后台线程上执行，你必须使用任务队列（Task Queue）API。

override fun onAttachedToEngine(@NonNull flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
  val taskQueue =
      flutterPluginBinding.binaryMessenger.makeBackgroundTaskQueue()
  channel = MethodChannel(flutterPluginBinding.binaryMessenger,
                          "com.example.foo",
                          StandardMethodCodec.INSTANCE,
                          taskQueue)
  channel.setMethodCallHandler(this)
}

@Override
public void onAttachedToEngine(@NonNull FlutterPluginBinding binding) {
  BinaryMessenger messenger = binding.getBinaryMessenger();
  BinaryMessenger.TaskQueue taskQueue =
      messenger.makeBackgroundTaskQueue();
  channel =
      new MethodChannel(
          messenger,
          "com.example.foo",
          StandardMethodCodec.INSTANCE,
          taskQueue);
  channel.setMethodCallHandler(this);
}

为了让通道的平台侧处理器在 iOS 应用的后台线程上执行，你必须使用任务队列（Task Queue）API。

public static func register(with registrar: FlutterPluginRegistrar) {
  let taskQueue = registrar.messenger().makeBackgroundTaskQueue?()
  let channel = FlutterMethodChannel(name: "com.example.foo",
                                     binaryMessenger: registrar.messenger(),
                                     codec: FlutterStandardMethodCodec.sharedInstance(),
                                     taskQueue: taskQueue)
  let instance = MyPlugin()
  registrar.addMethodCallDelegate(instance, channel: channel)
}

+ (void)registerWithRegistrar:(NSObject<FlutterPluginRegistrar>*)registrar {
  NSObject<FlutterTaskQueue>* taskQueue =
      [[registrar messenger] makeBackgroundTaskQueue];
  FlutterMethodChannel* channel =
      [FlutterMethodChannel methodChannelWithName:@"com.example.foo"
                                  binaryMessenger:[registrar messenger]
                                            codec:[FlutterStandardMethodCodec sharedInstance]
                                        taskQueue:taskQueue];
  MyPlugin* instance = [[MyPlugin alloc] init];
  [registrar addMethodCallDelegate:instance channel:channel];
}

为了符合通道对 UI 线程的要求，你可能需要从后台线程跳转到 Android 的 UI 线程来执行通道方法。在 Android 中，你可以通过向 Android UI 线程的 Looper 发送一个 Runnable (post()) 来实现，这会使 Runnable 在下次机会时在主线程上执行。

Handler(Looper.getMainLooper()).post {
  // Call the desired channel message here.
}

new Handler(Looper.getMainLooper()).post(new Runnable() {
  @Override
  public void run() {
    // Call the desired channel message here.
  }
});

为了符合通道对主线程的要求，你可能需要从后台线程跳转到 iOS 的主线程来执行通道方法。在 iOS 中，你可以通过在主 调度队列 (dispatch queue) 上执行一个 代码块 (block) 来实现。

dispatch_async(dispatch_get_main_queue(), ^{
  // Call the desired channel message here.
});

DispatchQueue.main.async {
  // Call the desired channel message here.
}

以下是一些常用的平台通道 API 列表，你可以使用它们来编写平台相关代码：

• 用于 Flutter 的 MethodChannel：一个命名通道，你可以使用它通过异步方法调用与平台插件通信。默认情况下，此通道使用 StandardMessageCodec 编解码器。此通道不是类型安全的，这意味着调用和接收消息依赖于宿主和客户端声明相同的参数和数据类型，消息才能正常工作。

• 用于 Flutter 的 BasicMessageChannel：一个支持基本异步消息传递的命名通道，使用受支持的消息编解码器。非类型安全。

• 平台引擎嵌入 API (Engine Embedder APIs)：这些平台相关 API 包含平台相关的通道 API。

你可以创建自己的编解码器或使用现有的编解码器。以下是一些可以与平台相关代码一起使用的现有编解码器列表：

• StandardMessageCodec：一种常用的消息编解码器，它将广泛的数据类型编码和解码为一种平台无关的二进制格式，以便在平台通道上传输。当你发送和接收值时，值的序列化和反序列化会自动发生。有关支持的数据类型列表，请参阅 平台通道数据类型支持。

• BinaryCodec：一种在 Flutter 应用的 Dart 侧与原生平台侧之间传递原始二进制数据的消息编解码器。它不对数据结构执行任何更高级别的编码或解码。

• StringCodec：一种使用 UTF-8 编码对字符串进行编码和解码的消息编解码器。

• JSONMessageCodec：一种使用 UTF-8 编码对 JSON 格式数据进行编码和解码的消息编解码器。

• FirestoreMessageCodec：一种处理 Flutter 应用与原生 Firebase Firestore SDK（在 Android 和 iOS 上）之间通过平台通道发送的消息交换的消息编解码器。

如果你期望在多个 Flutter 应用中使用平台相关代码，可以考虑将代码分离到一个位于主应用目录之外的平台插件中。详情请参阅 开发软件包。

要与 Flutter 生态系统中的其他开发者共享你的平台相关代码，请参阅 发布软件包。