Understanding Flutter Platform Channels: Architecture, Code Samples, and Call Flow

Flutter uses a flexible UI framework called Platform Channel to enable API calls between Dart and native Android/iOS code without code generation, relying on binary message passing similar to network services.

Platform Channel Overview

Three channel types are provided:

BasicMessageChannel – supports string and semi‑structured data.

MethodChannel – supports method calls from Flutter to the platform and vice‑versa.

EventChannel – supports data‑stream communication.

All channels share three member variables:

name – unique identifier for the channel.

messenger – the binary messenger handling message transport.

codec – the message encoder/decoder (MessageCodec or MethodCodec).

BasicMessageChannel Example

public final class BasicMessageChannel
{
private final BinaryMessenger messenger;
private final String name;
private final MessageCodec
codec;
public void setMessageHandler(final MessageHandler
handler) {
messenger.setMessageHandler(name, handler == null ? null : new IncomingMessageHandler(handler));
}
public interface MessageHandler
{ void onMessage(T message, Reply
reply); }
private final class IncomingMessageHandler implements BinaryMessageHandler {
private final MessageHandler
handler;
private IncomingMessageHandler(MessageHandler
handler) { this.handler = handler; }
@Override public void onMessage(ByteBuffer message, final BinaryReply callback) { /* ... */ handler.onMessage(); }
}
}

MethodChannel Example

public final class MethodChannel {
private final BinaryMessenger messenger;
private final String name;
private final MethodCodec codec;
public void setMethodCallHandler(final @Nullable MethodCallHandler handler) {
messenger.setMessageHandler(name, handler == null ? null : new IncomingMethodCallHandler(handler));
}
public interface Result { void success(@Nullable Object result); void error(String errorCode, @Nullable String errorMessage, @Nullable Object errorDetails); void notImplemented(); }
public interface MethodCallHandler { void onMethodCall(MethodCall call, Result result); }
private final class IncomingMethodCallHandler implements BinaryMessageHandler {
private final MethodCallHandler handler;
@Override public void onMessage(ByteBuffer message, final BinaryReply reply) { /* decode, call handler, reply */ }
}
}

EventChannel Example

public final class EventChannel {
private final BinaryMessenger messenger;
private final String name;
private final MethodCodec codec;
public void setStreamHandler(final StreamHandler handler) {
messenger.setMessageHandler(name, handler == null ? null : new IncomingStreamRequestHandler(handler));
}
public interface StreamHandler { void onListen(Object arguments, EventSink events); void onCancel(Object arguments); }
public interface EventSink { void success(Object event); void error(String errorCode, String errorMessage, Object errorDetails); void endOfStream(); }
private final class IncomingStreamRequestHandler implements BinaryMessageHandler { /* ... */ }
}

Codecs

Two main codecs are used:

MessageCodec – encodes/decodes basic data for BasicMessageChannel.

MethodCodec – encodes/decodes method calls and results for MethodChannel and EventChannel.

Implementations include BinaryCodec, StringCodec, JSONMessageCodec, StandardMessageCodec, JSONMethodCodec, and StandardMethodCodec. StandardMessageCodec writes a type flag followed by the value, handling endianness and primitive types.

MethodChannel Call Flow (Dart → Native → Java → Dart)

When invokeMethod is called, the method name and arguments are wrapped in a MethodCall , encoded by MethodCodec , and sent via BinaryMessages.send . This eventually calls the native method Window._sendPlatformMessage , which forwards the message to the platform view.

On Android, the message reaches FlutterViewHandlePlatformMessage via JNI, which invokes FlutterJNI.handlePlatformMessage . The registered PlatformMessageHandlerImpl looks up the channel in a Map<String, BinaryMessageHandler> , creates a ByteBuffer , and calls the handler’s onMessage method.

The handler (e.g., IncomingMethodCallHandler ) decodes the MethodCall , invokes the user‑provided MethodCallHandler , and uses a Result callback to encode the response. The response is sent back through BinaryReply.reply , which calls FlutterJNI.invokePlatformMessageResponseCallback . This native call routes the data back to the original Dart Future , where MethodCodec.decodeEnvelope produces the final result.

Handlers

Three handler interfaces correspond to the three channel types:

MessageHandler – for BasicMessageChannel .

MethodCallHandler – for MethodChannel .

StreamHandler – for EventChannel .

These are registered via setMessageHandler , setMethodCallHandler , or setStreamHandler on the respective channel objects, which store the handlers in the view’s mMessageHandlers map.

Summary

The article provides a complete walkthrough of Flutter’s Platform Channel mechanism, covering channel types, codec design, code examples, and the full end‑to‑end message flow across Dart, native C++, JNI, and Java layers, enabling developers to create efficient cross‑platform plugins.