Flutter Platform Channel 通信机制与原理详解

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)));
      });
    }
  }
}

2. MethodChannel

Android 端实现

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() {
                // 未实现
            }
});

Flutter 端实现

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;
  }
}

3. EventChannel

Android 端实现

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) {
        // 取消监听时调用
    }
});

Flutter 端实现

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;
  }
}

四、底层通信机制深度解析

1. 消息流转路径

当 Flutter 调用 Native 方法时，数据流向如下：

1. Dart 层通过 invokeMethod 发起请求。
2. MethodChannel 使用 StandardMethodCodec 将参数编码为 ByteData。
3. BinaryMessages.send 将数据传递给 Engine 层。
4. Engine 层通过 JNI/ObjC 桥接将数据转发给 Native 侧。
5. Native 侧 MethodChannel 接收数据，解码后调用注册的 Handler。
6. 处理完成后，Native 侧通过 Result.success/error 返回数据。
7. 数据沿原路返回至 Dart 层，完成异步回调。

2. 线程模型

• Dart 层：通常运行在主线程（UI Thread），但 async/await 允许非阻塞操作。
• Engine 层：拥有独立的 IO 线程池处理网络、文件等 I/O 操作。
• Native 层：Android 端通常在主线程处理 UI 相关，后台线程处理计算；iOS 端类似。建议在 Native 端进行耗时操作时使用子线程，避免阻塞 UI。

3. 性能优化建议

• 减少序列化开销：尽量使用 BasicMessageChannel 传输简单数据，避免复杂的对象嵌套。
• 批量传输：对于高频小数据，考虑合并传输，减少上下文切换次数。
• 避免大对象：不要在 Channel 中传递过大的图片或文件数据，应传递 URI 或 Base64 字符串。
• 缓存策略：在 Native 端缓存常用配置，减少重复查询。

五、安全与调试

1. 安全性

• Channel 命名：不要使用公开可预测的名称，防止恶意应用劫持通信。
• 权限校验：在 Native 端收到请求后，务必校验当前应用的权限状态。
• 数据加密：敏感数据在传输前应进行加密处理。

2. 调试技巧

• Logcat/Xcode Console：查看 Native 端日志。
• Flutter DevTools：监控 Dart 层的内存和性能。
• Mocking：在单元测试中使用 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 类型，并遵循上述的性能与安全最佳实践，以确保混合应用的稳定性和高效性。