作为一个UI框架，Flutter提供了三种通道来和原生平台通信。

• BasicMessageChannel：它提供类似于BinaryMessages的基本消息传递服务，但可自定义消息编解码器，支持发送字符串或半结构化消息。
• MethodChannel：它使用异步方法调用的方式进行平台通信。
• EventChannel：它使用事件流的方式进行平台通信。

image.png

三种方式的设计是非常相似的，分别维护了两个成员属性：

• name：用来标识通道。
• codec：消息编解码器。

另外，三种方式其实都是通过BinaryMessages来进行消息的传递，它负责将二进制消息发送到平台插件并从平台插件接收二进制消息。最后通过消息编解码器来将二进制信息转换成我们需要的数据类型，注意三种通信方式都是双向的。以BasicMessageChannel为例：

  Future<T> send(T message) async {
    return codec.decodeMessage(await BinaryMessages.send(name, codec.encodeMessage(message)));
  }

细心的同学会发现，图上还有一个OptionalMethodChannel，这并不是一种新的通信方式，而是MethodChannel的进一步封装，如果找不到对应插件，返回的是null，而不再抛出MissingPluginException异常。

class OptionalMethodChannel extends MethodChannel{
  ...
  @override
  Future<T> invokeMethod<T>(String method, [dynamic arguments]) async {
    try {
      final T result = await super.invokeMethod<T>(method, arguments);
      return result;
    } on MissingPluginException {
      return null;
    }
  } 
  ...
}

BasicMessageChannel

使用介绍

BasicMessageChannel_Flutter.png BasicMessageChannel_Android.png

三种通道分别在flutter和其他平台都提供了相关实现，并提供了相似的api，这里以BasicMessageChannel为例展示一下。

成员属性

• name：通道名字，要保证通信的通道在flutter和native端保持一致。
• codec：消息的编解码器，同样要保证通信的通道在flutter和native端保持一致。
• messenger：消息的发送器，类似于flutter中的BinaryMessages。

Api接口

发送消息

flutter端：可以看到发送消息是个异步方法，大概执行顺序就是先将数据编码成字节数据，通过BinaryMessages传输，等待native返回数据，再解码成我们需要的数据，如果native没有返数据，则Future为null。

  Future<T> send(T message) async {
    return codec.decodeMessage(await BinaryMessages.send(name, codec.encodeMessage(message)));
  }

android端：其实实现是类似的，只不过不是使用Future，而是用回调的方式来监听返回数据。

    public void send(T message) {
        this.send(message, (BasicMessageChannel.Reply)null);
    }

    public void send(T message, BasicMessageChannel.Reply<T> callback) {
        this.messenger.send(this.name, this.codec.encodeMessage(message), callback == null ? null : new BasicMessageChannel.IncomingReplyHandler(callback));
    }

接收消息

flutter端：我们可以看到传入的参数是一个异步函数，handler接收的参数为native平台发送的数据，handler的返回值将作为响应返回给native端。

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

android端：同样是通过接口回调的方式来接收和响应消息的传递。

    public void setMessageHandler(BasicMessageChannel.MessageHandler<T> handler) {
        this.messenger.setMessageHandler(this.name, handler == null ? null : new BasicMessageChannel.IncomingMessageHandler(handler));
    }

    public interface MessageHandler<T> {
        void onMessage(T message, BasicMessageChannel.Reply<T> reply);
    }

示例代码

我们来做这样一个demo，flutter发送一条消息到native，native收到消息后给个回复，并发送一条新的消息到flutter，flutter收到后再回复给native。
flutter：

PluginChannel.listenBasicMessage();
RaisedButton(
            onPressed: () {
              PluginChannel.sendBasicMessage();
            },
            child: Text("BasicMessageChannel"),
          )
...
class PluginChannel {
  static const _basicMessageChannelName = "study_3/basicMessageChannel";
  static const _basicMessageChannel = BasicMessageChannel(_basicMessageChannelName, StandardMessageCodec());

  static void listenBasicMessage(){
    _basicMessageChannel
        .setMessageHandler((result) async{
      print('flutter listen:$result');
      return "flutter response to native";
    });
  }
  static void sendBasicMessage() {
    _basicMessageChannel
        .send("flutter send to native")
        .then((result) {
      print('flutter receive response:$result');
    });
  }
}

android:

    private val BASIC_MESSAGE_CHANNEL = "study_3/basicMessageChannel"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        GeneratedPluginRegistrant.registerWith(this)

        basicMessageChanelDemo()
    }
    private fun basicMessageChanelDemo(){
        BasicMessageChannel(this.flutterView,BASIC_MESSAGE_CHANNEL, StandardMessageCodec.INSTANCE)
                .setMessageHandler { any, reply ->
                    println("android listen:$any")
                    reply.reply("android response to flutter")


                    BasicMessageChannel(this.flutterView,BASIC_MESSAGE_CHANNEL, StandardMessageCodec.INSTANCE)
                            .send("android send to flutter"){
                                println("android receive response:$it")
                            }
                }
    }

日志：

I/System.out(27557): android listen:flutter send to native
I/flutter (27557): flutter receive response:android response to flutter
I/flutter (27557): flutter listen:android send to flutter
I/System.out(27557): android receive response:flutter response to native

MethodChannel

一些想法

MethodChannel通过传递方法名和参数，来达到通信的效果，给我的感觉和BasicMessageChannel并没有本质上的不同，使用BasicMessageChannel传递一个数据，做一系列操作再返回数据，给我的感觉效果是一样的。为了验证自己的想法，大概翻了一下源码：
首先看两者的发送数据方法：

  ///BasicMessageChannel
  Future<T> send(T message) async {
    return codec.decodeMessage(await BinaryMessages.send(name, codec.encodeMessage(message)));
  }

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

两者内部的实现逻辑基本上是一样的，编码成二进制、BinaryMessages发送、解码。都是调用的BinaryMessages的send方法，唯一区别就是编解码器codec的不同。下面来看看codec的实现：

  ///BasicMessageChannel    StandardMessageCodec
  ByteData encodeMessage(dynamic message) {
    if (message == null)
      return null;
    final WriteBuffer buffer = WriteBuffer();
    writeValue(buffer, message);
    return buffer.done();
  }

  ///MethodChannel     StandardMethodCodec
  const StandardMethodCodec([this.messageCodec = const StandardMessageCodec()]);

  ByteData encodeMethodCall(MethodCall call) {
    final WriteBuffer buffer = WriteBuffer();
    messageCodec.writeValue(buffer, call.method);
    messageCodec.writeValue(buffer, call.arguments);
    return buffer.done();
  }

我们可以看到StandardMethodCodec中的messageCodec默认为StandardMessageCodec，而且编码方法和StandardMessageCodec的编码方法是一样的。默认实现就是相当于把方法名和参数封装成了一个MethodCall对象，再通过BasicMessageChannel传递。

Api

//发送
Future<T> invokeMethod<T>(String method, [dynamic arguments]) async {}
//接收
void setMethodCallHandler(Future<dynamic> handler(MethodCall call)) {}

Api不再赘述，设计和使用都类似于BasicMessageChannel，发送的时候传入方法名和参数，返回一个Future来监听响应。接收的时候传入一个高阶函数，参数为收到的信息，返回值为要响应的数据。

示例代码

依然是一个flutter和android相互调用的demo。
flutter：

PluginChannel.listenMethod();

onPressed: () {
   PluginChannel.sendBasicMessage();
},

class PluginChannel {
  static const _methodChannelName = "study_3/methodChannel";
  static const _methodChannel = MethodChannel(_methodChannelName);

  static void invokeMethod() {
    _methodChannel.invokeMethod("getAge", {"name": "lili"}).then((result) {
      print('flutter receive response:$result');
    });
  }

  static void listenMethod() {
    _methodChannel.setMethodCallHandler((methodCall) async {
      print('flutter listen:$methodCall');
      return "男";
    });
  }
}

android:

private val METHOD_CHANNEL = "study_3/methodChannel"
override fun onCreate(savedInstanceState: Bundle?) {
    methodChannelDemo()
}


    private fun methodChannelDemo(){
        MethodChannel(this.flutterView,METHOD_CHANNEL)
                .setMethodCallHandler { methodCall, result ->
                    println("android listen:${methodCall.method} \t ${methodCall.arguments}")
                    when(methodCall.method){
                        "getAge" -> {
                            result.success(getAge(methodCall.argument<String>("name")))
                        }
                    }


                    MethodChannel(this.flutterView,METHOD_CHANNEL)
                            .invokeMethod("getSex", mapOf(Pair("name","tom")), object : MethodChannel.Result {
                                override fun notImplemented() {
                                    println("android receive notImplemented")
                                }

                                override fun error(p0: String?, p1: String?, p2: Any?) {
                                    println("android receive error")
                                }

                                override fun success(p0: Any?) {
                                    println("android receive response:$p0")
                                }
                            })
                }
    }

    private fun getAge(name:String?): Int{
        return when(name){
            "lili" -> 18
            "tom" -> 19
            "allen" -> 20
            else -> 0
        }
    }

日志：

I/System.out( 9700): android listen:getAge {name=lili}
I/flutter ( 9700): flutter receive response:18
I/flutter ( 9700): flutter listen:MethodCall(getSex, {name: tom})
I/System.out( 9700): android receive response:男

EventChannel

Api

EventChannel并没有分别提供发送和收听消息的方法，它只提供了一个receiveBroadcastStream方法，用于发送消息，同时返回一个流（Stream），用于监听平台插件成功返回的所有事件信息，这个流可以被监听不止一次。因此我们可以用于native端需要持续传递数据到flutter的情况，比如监听电量，调用摄像头等等。

  Stream<dynamic> receiveBroadcastStream([dynamic arguments]) {
    final MethodChannel methodChannel = MethodChannel(name, codec);
    StreamController<dynamic> controller;
    controller = StreamController<dynamic>.broadcast(onListen, onCancel);
    return controller.stream;
  }

上面是receiveBroadcastStream的抽象代码，总共做了两件事：

• 创建一个MethodChannel，传入自己的name和codec属性。
• 创建一个StreamController，并返回流。
  StreamController.broadcast是一个命名构造函数，它返回一个广播流，可以不止一次被监听，它是惰性的，在首次被订阅时调用onListen，不再订阅时调用onCancel。如果之后继续订阅，则再次调用onListen。
  那么我们来继续看下receiveBroadcastStream中的onListen做了什么：

      BinaryMessages.setMessageHandler(name, (ByteData reply) async {
        if (reply == null) {
          controller.close();
        } else {
          try {
            controller.add(codec.decodeEnvelope(reply));
          } on PlatformException catch (e) {
            controller.addError(e);
          }
        }
        return null;
      });
      try {
        await methodChannel.invokeMethod<void>('listen', arguments);
      } catch (exception, stack) {
        FlutterError.reportError(FlutterErrorDetails(
          exception: exception,
          stack: stack,
          library: 'services library',
          context: 'while activating platform stream on channel $name',
        ));
      }

可以看到onListen中依然是做了两件事情：

• 设置回调来接收平台插件返回的消息。
• 通过之前创建的MethodChannel发送一条消息，方法名定死为listen，参数为receiveBroadcastStream传入的可选参数。
  最后再来看下receiveBroadcastStream中的onCancel：

      BinaryMessages.setMessageHandler(name, null);
      try {
        await methodChannel.invokeMethod<void>('cancel', arguments);
      } catch (exception, stack) {
        FlutterError.reportError(FlutterErrorDetails(
          exception: exception,
          stack: stack,
          library: 'services library',
          context: 'while de-activating platform stream on channel $name',
        ));
      }

依然两件事：

• 移除这个通道。
• 用之前创建的MethodChannel发送一条消息，方法名定死为cancel，参数为receiveBroadcastStream传入的可选参数。

可以想象，native平台肯定也定义了一个MethodChannel，用来接收listen和cancel方法，我们来验证一下，以Android端为例，EventChannel部分源码：

       public void onMessage(ByteBuffer message, BinaryReply reply) {
            MethodCall call = EventChannel.this.codec.decodeMethodCall(message);
            if (call.method.equals("listen")) {
                this.onListen(call.arguments, reply);
            } else if (call.method.equals("cancel")) {
                this.onCancel(call.arguments, reply);
            } else {
                reply.reply((ByteBuffer)null);
            }
        }

我们可以看到，当收到消息的时候，有三种情况：

• 收到listen方法，则调用onListen。
• 收到cancel方法，则调用onCancel。
• 其他，则返回null，此时flutter端收到null则会关闭这个流。

示例代码

flutter:

class PluginChannel {

  static const _eventChannelName = "study_3/eventChannel";
  static const _eventChannel = EventChannel(_eventChannelName);

  static void event() {
    _eventChannel.receiveBroadcastStream("event arg")
        .listen((result) {
      print('flutter listen:$result');
    });
  }
}

android：

    private fun eventChannelDemo(){
        EventChannel(this.flutterView,EVENT_CHANNEL)
                .setStreamHandler(object : EventChannel.StreamHandler {
                    override fun onListen(p0: Any?, events: EventChannel.EventSink?) {
                        println("android onListen:$p0")

                        events?.success(1)
                        events?.success(2)
                        events?.success(3)
                        events?.success(4)
                        events?.endOfStream()
                        events?.success(5)
                    }

                    override fun onCancel(p0: Any?) {
                        println("android onCancel:$p0")
                    }
                })
    }

日志：

I/System.out( 9271): android onListen:event arg
I/flutter ( 9271): flutter listen:1
I/flutter ( 9271): flutter listen:2
I/flutter ( 9271): flutter listen:3
I/flutter ( 9271): flutter listen:4
I/System.out( 9271): android onCancel:event arg

完整代码地址