Flutter MethodChannel多次返回结果报Reply already submitted异常

MethodChannel的单次方法调用是请求-响应一对一模型，每个来自Dart侧的invokeMethod调用，原生端对应的result回调只能执行一次：不管是success()、error()还是notImplemented()，重复调用就会抛出Reply already submitted异常，这是平台通道的设计规则，不是bug。

你当前代码里已经埋了触发这个异常的写法：

• 分支判断没加return，匹配到getBatteryLevel或者getPluginData方法执行完result.success()之后，代码会继续往下走到else分支的result.notImplemented()，等于单次调用返回了两次
• 如果想在原生端主动、多次推送数据给Dart（不是等Dart发请求才返回），用MethodChannel的返回回调本身就不适用

根据你的实际场景选对应实现即可：

场景1：单次调用需要返回多组数据 #

如果是Dart发一次请求，原生端要把电池电量、插件信息两组数据一起返回，直接把数据封装成集合一次返回即可，同时修复分支判断漏写return的问题。

Android端修改代码 #

给每个分支补全return逻辑，多组数据打包成Map返回：

new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
        .setMethodCallHandler(
                (call, result) -> {
                    // 匹配到对应方法后，执行完返回逻辑直接return，不要继续走后续分支
                    if (call.method.equals("getBatteryLevel")) {
                        int batteryLevel = getBatteryLevel();
                        if (batteryLevel != -1) {
                            result.success(batteryLevel);
                        } else {
                            result.error("UNAVAILABLE", "Battery level not available.", null);
                        }
                        return; // 补return，避免走到后面的notImplemented
                    }
                    if(call.method.equals("getAllData")){
                        // 把多组数据打包一次返回
                        HashMap<String, Object> resMap = new HashMap<>();
                        resMap.put("batteryLevel", getBatteryLevel());
                        resMap.put("pluginData", getPluginData());
                        result.success(resMap);
                        return; // 补return
                    }
                    // 所有方法都没匹配到才走notImplemented
                    result.notImplemented();
                }
        );

Dart端对应修改 #

Future<void> _getAllData() async {
  try {
    final Map res = await platform.invokeMethod('getAllData');
    setState(() {
      _batteryLevel = 'Battery level at ${res['batteryLevel']} % .';
      _pluginData = 'Plugin Data at ${res['pluginData']} .';
    });
  } on PlatformException catch (e) {
    setState(() {
      _batteryLevel = "Failed to get battery level: '${e.message}'.";
      _pluginData = "Failed to get Plugin Data: '${e.message}'.";
    });
  }
}

场景2：原生端需要主动、多次推送数据给Dart #

如果是原生端有持续事件（比如电量变化、传感器数据更新）不需要等Dart发请求，要随时推多组数据到Dart侧，用EventChannel实现流推送即可，这是官方专门提供的处理持续事件/多组数据推送的通道，完全不会有重复回复的问题。

Android端EventChannel实现 #

// 定义EventChannel名称
private static final String EVENT_CHANNEL = "samples.flutter.dev/battery_event";

@Override
public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
    super.configureFlutterEngine(flutterEngine);
    // 之前的MethodChannel代码保留，新增EventChannel逻辑
    new EventChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), EVENT_CHANNEL)
            .setStreamHandler(
                    new EventChannel.StreamHandler() {
                        private BroadcastReceiver batteryReceiver;
                        @Override
                        public void onListen(Object arguments, EventChannel.EventSink events) {
                            // Dart开始监听流之后，这里可以随时多次调用events.success()推送数据
                            // 示例：监听电量变化，每次变化都推数据给Dart
                            batteryReceiver = new BroadcastReceiver() {
                                @Override
                                public void onReceive(Context context, Intent intent) {
                                    int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
                                    int scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
                                    int batteryPct = (int) (level * 100 / (float)scale);
                                    // 这里可以多次调用，不会抛Reply already submitted
                                    HashMap<String, Object> eventData = new HashMap<>();
                                    eventData.put("batteryLevel", batteryPct);
                                    eventData.put("pluginData", getPluginData());
                                    events.success(eventData);
                                }
                            };
                            registerReceiver(batteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
                        }

                        @Override
                        public void onCancel(Object arguments) {
                            // Dart取消监听时注销广播，避免内存泄漏
                            if (batteryReceiver != null) {
                                unregisterReceiver(batteryReceiver);
                                batteryReceiver = null;
                            }
                        }
                    }
            );
}

Dart端EventChannel监听代码 #

// 新增EventChannel定义
static const eventChannel = EventChannel('samples.flutter.dev/battery_event');

// initState里启动监听
@override
void initState() {
  super.initState();
  eventChannel.receiveBroadcastStream().listen((event) {
    // 每次原生端推数据都会走到这里，可多次接收
    final Map eventData = event as Map;
    setState(() {
      _batteryLevel = 'Battery level at ${eventData['batteryLevel']} % .';
      _pluginData = 'Plugin Data at ${eventData['pluginData']} .';
    });
  }, onError: (e) {
    // 处理原生端抛出的错误
  });
}

• 所有MethodChannel.Result的三个回调方法（success/error/notImplemented），单次方法调用绝对只能执行其中一个，且只能执行一次。写完分支逻辑一定要检查有没有漏写return，避免后续分支重复触发回调。
• 不要试图在MethodCallHandler里开子线程延迟、重复调用result.success()，这类操作一定会触发异常。持续推送、多次发数据的场景直接换EventChannel是最省事的官方方案，不需要自己额外实现队列、调用标记位这类兼容逻辑。

内容的提问来源于stack exchange，提问作者Shahryar Rafique