Flutter 通过 Platform Channel 实现 Dart 与原生代码交互。主要包含 BasicMessageChannel、MethodChannel 和 EventChannel 三种类型，分别适用于字符串传输、方法调用及事件流场景。底层基于 BinaryMessenger 和 Codec 进行二进制数据编解码。详细解析各通道的使用方式、源码逻辑、性能优化及安全注意事项，帮助开发者在混合开发中高效处理跨平台通信。
在 Flutter 混合开发架构中，Dart 代码运行在 Dart VM 或 Skia 引擎上，而原生功能（如相机、蓝牙、系统设置等）则由宿主平台（Android/iOS）提供。为了实现跨语言交互，Flutter 提供了 Platform Channel 机制。本文将深入解析 Platform Channel 的工作原理、三种核心通道类型、底层实现细节以及最佳实践。
Flutter 定义了三种不同类型的 Channel，它们各自承担不同的通信职责：
这三种 Channel 之间互相独立，各有用途，但它们在设计上却非常相近。每种 Channel 均有三个重要成员变量：
BinaryMessenger 是 Flutter 内部处理二进制消息的核心接口。它维护了一个映射表，将 Channel 名称映射到对应的消息处理器。
BinaryMessages 是 BinaryMessenger 的具体实现类，封装了底层引擎的通信能力。所有 Channel 的通信最终都依赖于 BinaryMessages.send 和 BinaryMessages.setMessageHandler。
Flutter 采用了二进制字节流作为数据传输协议。发送方需要把数据编码成二进制数据，接收方再把数据解码成原始数据。负责编解码操作的就是 Codec。
每个 Channel 中都使用到了 BinaryMessages，它起到了信使的作用，负责将信息进行跨平台的搬运，是消息发送和接受的工具。
BasicMessageChannel mBasicMessageChannel = new BasicMessageChannel(getFlutterView(), "basic_channel", StringCodec.INSTANCE);
mBasicMessageChannel.setMessageHandler(new BasicMessageChannel.MessageHandler() {
// 接受消息
@Override
public void onMessage(Object o, BasicMessageChannel.Reply reply) {
Log.e("basic_channel", "接收到来自 flutter 的消息:" + o.toString());
reply.reply("回馈消息");
}
});
// 发送消息
mBasicMessageChannel.send("向 flutter 发送消息");
// 发送消息并接受 flutter 的回馈
mBasicMessageChannel.send("向 flutter 发送消息", new BasicMessageChannel.Reply() {
@Override
public void reply(Object o) {
// 处理 Flutter 返回的数据
}
});
const basicMessageChannel = const BasicMessageChannel('basic_channel', StringCodec());
// 接受并回复消息
basicMessageChannel.setMessageHandler(
(String message) => Future<String>(() {
setState(() {
this.message = message;
});
return "回复 native 消息";
}),
);
// 发送消息
basicMessageChannel.send("来自 flutter 的 message");
// Flutter 并没有发送并接受回复消息的 send(T message, BasicMessageChannel.Reply<T> callback) 方法
class BasicMessageChannel<T> {
const BasicMessageChannel(this.name, this.codec);
final String name;
final MessageCodec<T> codec;
Future<T> send(T message) async {
return codec.decodeMessage(await BinaryMessages.send(name, codec.encodeMessage(message)));
}
void setMessageHandler(Future<T> handler(T message)) {
if (handler == null) {
BinaryMessages.setMessageHandler(name, null);
} else {
BinaryMessages.setMessageHandler(name, (ByteData message) async {
return codec.encodeMessage(await handler(codec.decodeMessage(message)));
});
}
}
}
MethodChannel mMethodChannel = new MethodChannel(getFlutterView(), "method_channel");
mMethodChannel.setMethodCallHandler(new MethodChannel.MethodCallHandler() {
// 响应 flutter 端的调用
@Override
public void onMethodCall(MethodCall methodCall, MethodChannel.Result result) {
if (methodCall.method.equals("noticeNative")) {
todo();
result.success("接受成功");
} else {
result.notImplemented();
}
}
});
// 原生调用 flutter
mMethodChannel.invokeMethod("noticeFlutter", "argument", new MethodChannel.Result() {
@Override
public void success(Object o) {
// 回调成功
}
@Override
public void error(String s, String s1, Object o) {
// 回调失败
}
@Override
public void notImplemented() {
// 未实现
}
});
const methodChannel = const MethodChannel('method_channel');
Future<Null> getMessageFromNative() async {
// Flutter 调原生方法
try {
// 回调成功
final String result = await methodChannel.invokeMethod('noticeNative');
setState(() {
method = result;
});
} on PlatformException catch (e) {
// 回调失败
print(e);
}
}
methodChannel.setMethodCallHandler(
(MethodCall methodCall) => Future<String>(() {
// 响应原生的调用
if(methodCall.method == "noticeFlutter"){
setState(() {
// 更新 UI
});
}
}),
);
class MethodChannel {
const MethodChannel(this.name, [this.codec = const StandardMethodCodec()]);
final String name;
final MethodCodec codec;
void setMethodCallHandler(Future<dynamic> handler(MethodCall call)) {
BinaryMessages.setMessageHandler(
name,
handler == null ? null : (ByteData message) => _handleAsMethodCall(message, handler),
);
}
Future<ByteData> _handleAsMethodCall(ByteData message, Future<dynamic> handler(MethodCall call)) async {
final MethodCall call = codec.decodeMethodCall(message);
try {
return codec.encodeSuccessEnvelope(await handler(call));
} on PlatformException catch (e) {
return codec.encodeErrorEnvelope(code: e.code, message: e.message, details: e.details);
} on MissingPluginException {
return null;
} catch (e) {
return codec.encodeErrorEnvelope(code: 'error', message: e.toString(), details: null);
}
}
Future<T> invokeMethod<T>(String method, [dynamic arguments]) async {
assert(method != null);
final ByteData result = await BinaryMessages.send(
name,
codec.encodeMethodCall(MethodCall(method, arguments)),
);
if (result == null) {
throw MissingPluginException('No implementation found for method $method on channel $name');
}
final T typedResult = codec.decodeEnvelope(result);
return typedResult;
}
}
EventChannel eventChannel = new EventChannel(getFlutterView(), "event_channel");
eventChannel.setStreamHandler(new EventChannel.StreamHandler() {
@Override
public void onListen(Object o, EventChannel.EventSink eventSink) {
eventSink.success("成功");
// eventSink.error("失败","失败","失败");
}
@Override
public void onCancel(Object o) {
// 取消监听时调用
}
});
const eventChannel = const EventChannel('event_channel');
eventChannel.receiveBroadcastStream().listen(_onEvent, onError: _onError);
void _onEvent(Object event) {
// 返回的内容
}
void _onError(Object error) {
// 返回的回调
}
其中：Object args 是传递的参数，EventChannel.EventSink eventSink 是 Native 回调 Dart 时的会回调函数，eventSink 提供 success、error 与 endOfStream 三个回调方法分别对应事件的不同状态。
class EventChannel {
const EventChannel(this.name, [this.codec = const StandardMethodCodec()]);
final String name;
final MethodCodec codec;
Stream<dynamic> receiveBroadcastStream([dynamic arguments]) {
final MethodChannel methodChannel = MethodChannel(name, codec);
StreamController<dynamic> controller;
controller = StreamController<dynamic>.broadcast(onListen: () async {
BinaryMessages.setMessageHandler(name, (ByteData reply) async {
// 处理事件流数据
});
try {
await methodChannel.invokeMethod<void>('listen', arguments);
} catch (exception, stack) {
// 处理 listen 异常
}
}, onCancel: () async {
BinaryMessages.setMessageHandler(name, null);
try {
await methodChannel.invokeMethod<void>('cancel', arguments);
} catch (exception, stack) {
// 处理 cancel 异常
}
});
return controller.stream;
}
}
当 Flutter 调用 Native 方法时，数据流向如下：
invokeMethod 发起请求。MethodChannel 使用 StandardMethodCodec 将参数编码为 ByteData。BinaryMessages.send 将数据传递给 Engine 层。MethodChannel 接收数据，解码后调用注册的 Handler。Result.success/error 返回数据。async/await 允许非阻塞操作。BasicMessageChannel 传输简单数据，避免复杂的对象嵌套。setMockMessageHandler 模拟 Channel 行为，无需真实设备即可验证逻辑。在 Flutter 与 Native 混合开发的模式下，Platform Channel 的应用场景非常多。理解 Platform Channel 的工作原理，有助于我们在从事这方面开发时能做到得心应手。
跟完 MethodChannel 的源码，会发现整个通信机制还挺简单的。先去不去理解 Codec 的话，等于就是将 dart 的变量，传到 Dart Native，然后交到 Java Native，再传到 Java。然后相反的路径，再从 Java 到 Dart。
然后再去看 BasicMessageChannel 就是没有 MethodCall 这个结构的，其他的也是走的 BinaryMessages.send 方法。然后在 Android 端，没有 IncomingMethodCallHandler 这个类，直接就是 BinaryMessageHandler。所以了解了 MethodChannel，BasicMessageChannel 原理自然就懂了。
同样的 EventChannel 则是基于 MethodChannel 来实现的，只是两端的 handler 会有一些特殊的处理方式，这个倒是与通信没有多大关系了，不过设计的也很简单，比较有意思。
在实际项目中，开发者应根据具体需求选择合适的 Channel 类型，并遵循上述的性能与安全最佳实践，以确保混合应用的稳定性和高效性。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online