swift flutter channel通信 flutter 与 native 通信

BasicMessageChannel 用法

Native端

BasicMessageChannel(@NonNull BinaryMessenger messenger, @NonNull String name, @NonNull MessageCodec<T> codec)

• BinaryMessenger messenger 消息信使，是消息的发送与接收工具
• String name Channel名字，唯一标识符
• MessageCodec<T> codec 消息的编解码器

setMessageHandler 方法原型

void setMessageHandler(BasicMessageChannel.MessageHandler<T> handler)

• BasicMessageChannel.MessageHandler<T> handler 消息处理器，配合BinaryMessager完成消息的处理。

在创建好BasicMessageChannel后，如果要让其接收来自Dart发来额消息，则需要调用它的setMessageHandler方法为其设置一个消息处理器。

BasicMessageChannel.MessageHandler 原型

public interface MessageHandler<T> {
	void onMessage(@Nullable T message, @NonNull Reply<T> reply);
 }

• onMessage(@Nullable T message, @NonNull Reply<T> reply) 用于接收消息，message 是消息内容，reply是回复此消息的回调函数。

send 方法原型

void send(@Nullable T message)
void send(@Nullable T message, @Nullable final Reply<T> callback)

• T message 要发送的消息
• Reply<T> callback 消息发出去后，收到Dart回复的消息函数

在创建好BasicMessageChannel后，如果要向Dart发送消息，可以调用它的send方法向Dart传递数据。

public class BasicMessageChannelPlugin implements BasicMessageChannel.MessageHandler<String> {

    private Activity activity;
    private BasicMessageChannel<String> messageChannel;

    public BasicMessageChannelPlugin(Activity activity, BinaryMessenger binaryMessenger) {
        this.activity = activity;
        messageChannel = new BasicMessageChannel<>(binaryMessenger, "channel", StringCodec.INSTANCE);
        // 设置消息处理器，处理来自Dart的消息
        messageChannel.setMessageHandler(this);
    }

    /**
     * 接收处理来自Dart的消息
     *
     * @param message
     * @param reply
     */
    @Override
    public void onMessage(@Nullable String message, @NonNull BasicMessageChannel.Reply<String> reply) {
        // 回复Dart端消息
        reply.reply("接收到来自Dart的消息:" + message);
        if (activity instanceof IShowMessage) {
            ((IShowMessage) activity).onShowMessage(message);
        }
        Toast.makeText(activity, message, Toast.LENGTH_SHORT).show();
    }

    /**
     * 向Dart传递消息，并接受Dart的反馈
     *
     * @param message
     * @param callback
     */
    void send(String message, BasicMessageChannel.Reply<String> callback) {
        messageChannel.send(message,callback);
    }
}

Dart端

static const BasicMessageChannel _basicMessageChannel =
      const BasicMessageChannel('channel', StringCodec());

  /// 设置setMessageHandler接收来自Native发来的消息，并回复Native
  void _receiveMessage() {
    _basicMessageChannel.setMessageHandler((message) => Future<String>(() {
          setState(() {
            showMessage = message;
          });
          return "收到Native消息${message}";
        }));
  }

  /// 调用send发送消息
  void _sendMessage(String message) async {
    String response;
    try {
      response = await _basicMessageChannel.send(message);
    } on PlatformException catch (e) {
      print(e);
    }
  }

MethodChannel用法

Native端

构造方法原型

MethodChannel(BinaryMessenger messenger, String name) 
MethodChannel(BinaryMessenger messenger, String name, MethodCodec codec)

• BinaryMessenger messenger 消息信使，是消息的发送和接收的工具
• String name Channel的名字，也是其唯一标识符
• MethodCodec codec 用作 MethodChannel的编解码器

setMethodCallHandler 方法原型

void setMethodCallHandler(final @Nullable MethodCallHandler handler)

• MethodCallHandler handler 消息处理器，配合BinaryMessager完成消息的处理

在创建好MethodChannel后，需要调用它的setMethodCallHandler方法为其设置一个消息处理器，以便能接收来自Dart端消息。

MethodChannel.MethodCallHandler 原型

public interface MethodCallHandler {
	void onMethodCall(@NonNull MethodCall call, @NonNull Result result);
 }

• onMethodCall(@NonNull MethodCall call, @NonNull Result result) 用于接收消息，call 是消息内容，它有两个成员变量String类型的call.method表示调用的方法名，Object类型的call.arguments表示调用方法所传递的入参，MethodChannel.Result result 是回复此消息的回调函数提供了 result.success、result.error、result.notImplemented方法调用。

public class MethodChannelPlugin implements MethodChannel.MethodCallHandler {

    private Activity activity;
    private MethodChannel methodChannel;

    public MethodChannelPlugin(Activity activity, BinaryMessenger binaryMessenger) {
        this.activity = activity;
        methodChannel = new MethodChannel(binaryMessenger, "channel");
        // 设置消息处理器，处理来自Dart的消息
        methodChannel.setMethodCallHandler(this);
    }

    /**
     * 向Dart传递消息，并接受Dart的反馈
     *
     * @param message
     * @param callback
     */
    void send(String message, BasicMessageChannel.Reply<String> callback) {
        methodChannel.invokeMethod(message, callback);
    }

    /**
     * 接收处理来自Dart的消息
     *
     * @param call
     * @param result
     */
    @Override
    public void onMethodCall(@NonNull MethodCall call, @NonNull MethodChannel.Result result) {
        switch (call.method) {
            case "showMessage":
                showMessage(call.arguments());
                break;
            default:
                result.notImplemented();
        }
    }

    /**
     * 显示从Dart端传递的消息
     *
     * @param arguments
     */
    private void showMessage(String arguments) {
        if (activity instanceof IShowMessage) {
            ((IShowMessage) activity).onShowMessage(arguments);
        }
    }
}

Dart端

static const MethodChannel _methodChannel = const MethodChannel('channel');
response = await _methodChannel.invokeMethod('send', 'value');

EventChannel 用法

Native端

构造方法原型

EventChannel(BinaryMessenger messenger, String name)
EventChannel(BinaryMessenger messenger, String name, MethodCodec codec)

• BinaryMessenger messenger 消息信使，是消息发送和接收的工具
• String name Channel的名字，唯一标识
• MethodCodec codec 用作EventChannel的编解码器

setStreamHandler 方法原型

void setStreamHandler(final StreamHandler handler)

• StreamHandler handler 消息处理器，配合BinaryMessager完成消息的处理，在创建好EventChannel后，如果要让其接收Dart发来的消息，则需要调用它的setStreamHandler 方法为其设置一个消息处理器。

StreamHandler 原型

public interface StreamHandler {
	void onListen(Object arguments, EventSink events);
	void onCancel(Object arguments);
}

• void onListen(Object arguments, EventSink events) Flutter Native 监听事件时调用，Object arguments是传递的参数，EventSink events 是 Native 回调Dart时的回调函数，EventSink提供success、error 与 endOfStream 三个回调方法分别对应事件的不同状态。
• void onCancel(Object arguments) Native 取消监听时调用

public class EventChannelPlugin implements EventChannel.StreamHandler {

    private List<EventChannel.EventSink> eventSinks = new ArrayList<>();


    static EventChannelPlugin registerWith(Activity activity, BinaryMessenger binaryMessenger) {
        EventChannelPlugin eventChannelPlugin = new EventChannelPlugin();
        new EventChannel(binaryMessenger, "channel")
                .setStreamHandler(eventChannelPlugin);
        return eventChannelPlugin;
    }

    /**
     * 向Dart传递消息，并接受Dart的反馈
     *
     * @param params
     */
    void sendEvent(Object params) {
        for (EventChannel.EventSink sink : eventSinks) {
            sink.success(params);
        }
    }


    @Override
    public void onListen(Object arguments, EventChannel.EventSink events) {
        eventSinks.add(events);
    }

    @Override
    public void onCancel(Object arguments) {

    }
}