摘要：在混合开发中，Flutter 与原生 Android (Kotlin) 的通信是核心难点。本文不仅讲解基础的 MethodChannel 用法，更深入探讨大数据传输的性能陷阱、异步线程调度以及Texture 共享内存方案，助你打造高性能混合 App。

1. 为什么需要通信？

虽然 Flutter 旨在“一次编写，到处运行”，但在以下场景中，我们必须回归原生（Kotlin）：

1. 硬件交互：蓝牙、NFC、传感器、相机底层控制。
2. 平台特性：Android 特有的 Service、BroadcastReceiver、Widget 嵌入。
3. 遗留代码复用：公司现有的 Java/Kotlin 业务逻辑库。
4. 性能极致优化：某些复杂计算或图形处理在原生层更高效。

Flutter 提供了三种主要的通信通道：

• MethodChannel：用于传递方法调用（最常用）。
• EventChannel：用于数据流事件（如传感器数据、电池状态）。
• BasicMessageChannel：用于持续的双向字符串/二进制消息传递。

本文将重点讲解最常用的 MethodChannel 及其性能优化。

2. 基础实战：MethodChannel 双向通信

2.1 Flutter 端 (Dart)

在 Flutter 侧，我们需要创建一个 MethodChannel，并定义一个唯一的名称（通常采用反向域名风格，如 com.example.app/native_bridge）。

import 'package:flutter/services.dart';

class NativeBridge {
  // 1. 定义 Channel 名称，必须与 Android 端一致
  static const MethodChannel _channel = MethodChannel('com.example.app/native_bridge');

  /// 调用 Android 原生方法获取设备信息
  static Future<String> getDeviceInfo() async {
    try {
      // invokeMethod 返回的是 dynamic，建议强转
      final String result = await _channel.invokeMethod('getDeviceInfo');
      return result;
    } on PlatformException catch (e) {
      print("Failed to get device info: '${e.message}'.");
      return "Unknown";
    }
  }

  /// 发送数据给 Android（无返回值）
  static Future<void> sendLogToNative(String log) async {
    await _channel.invokeMethod('logMessage', {'msg': log});
  }
  
  /// 监听来自 Android 的主动调用（可选，如果需要 Android 主动调 Flutter）
  static void setupHandler() {
    _channel.setMethodCallHandler((call) async {
      if (call.method == 'refreshUI') {
        print('Android requested UI refresh');
        // 执行 Flutter 侧逻辑，例如 setState
        return true;
      }
      throw MissingPluginException();
    });
  }
}

2.2 Android 端 (Kotlin)

在 Kotlin 侧，我们需要在 MainActivity 或自定义的 FlutterActivity 中注册这个 Channel。
 

package com.example.myapp

import android.os.Bundle
import android.util.Log
import io.flutter.embedding.android.FlutterActivity
import io.flutter.plugin.common.MethodChannel

class MainActivity : FlutterActivity() {

    private val CHANNEL = "com.example.app/native_bridge"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 获取 FlutterEngine 中的 DartExecutor
        val flutterEngine = this.flutterEngine ?: return
        val dartExecutor = flutterEngine.dartExecutor
        
        // 2. 创建 MethodChannel
        val channel = MethodChannel(dartExecutor.binaryMessenger, CHANNEL)
        
        // 3. 设置方法调用处理器
        channel.setMethodCallHandler { call, result ->
            when (call.method) {
                "getDeviceInfo" -> {
                    // 模拟耗时操作或获取真实数据
                    val deviceInfo = "Android ${android.os.Build.VERSION.RELEASE}"
                    // ✅ 成功返回结果
                    result.success(deviceInfo)
                }
                "logMessage" -> {
                    // 接收参数
                    val msg = call.argument<String>("msg")
                    Log.d("NativeBridge", "From Flutter: $msg")
                    // 无返回值
                    result.success(null) 
                }
                else -> {
                    // ✅ 方法未实现
                    result.notImplemented()
                }
            }
        }
    }
}

3. ️ 性能陷阱：千万不要这样传大图！

很多开发者在处理图片、音频或大 JSON 时，会直接将文件转为 Base64 字符串通过 MethodChannel 传递。

❌ 错误做法：

// Flutter: 读取文件 -> Base64 -> 发送
String base64Image = base64Encode(File('path/to/image.png').readAsBytesSync());
await channel.invokeMethod('saveImage', {'data': base64Image});

后果：

1. 内存翻倍：Base64 编码比原始二进制大 33%。
2. 序列化开销：JSON 序列化/反序列化大字符串非常慢。
3. 主线程阻塞：MethodChannel 默认在主线程处理，大数据传输会导致 UI 卡顿甚至 ANR。

✅ 正确做法：使用临时文件或 Content URI

对于大文件，应该将文件保存在本地，然后只传递文件路径或 URI。

Flutter 端优化代码

import 'dart:io';
import 'package:path_provider/path_provider.dart';

Future<void> saveLargeImageToNative(Uint8List imageBytes) async {
  // 1. 将图片写入临时文件
  final tempDir = await getTemporaryDirectory();
  final file = File('${tempDir.path}/temp_image.png');
  await file.writeAsBytes(imageBytes);

  // 2. 只传递文件路径
  await NativeBridge._channel.invokeMethod('saveImageFromPath', {
    'path': file.path
  });
  
  // 3. (可选) 清理临时文件
  // await file.delete();
}

Kotlin 端优化代码：

"saveImageFromPath" -> {
    val path = call.argument<String>("path")
    if (path != null) {
        val file = File(path)
        if (file.exists()) {
            // 直接在原生层读取文件，零拷贝传输
            processImage(file)
            result.success(true)
        } else {
            result.error("FILE_NOT_FOUND", "File does not exist", null)
        }
    } else {
        result.error("INVALID_ARG", "Path is null", null)
    }
}

4. 🚀 高阶优化：线程调度与异步

默认情况下，MethodChannel 的回调是在 Android 主线程 (UI Thread) 执行的。如果你的原生方法涉及网络请求、数据库读写或复杂计算，必须切换到子线程，否则会导致 App 卡死。

Kotlin 端：使用 Coroutine 异步处理

import kotlinx.coroutines.*

// 在 Activity 或 Fragment 中定义一个 CoroutineScope
private val mainScope = MainScope()

channel.setMethodCallHandler { call, result ->
    when (call.method) {
        "heavyCalculation" -> {
            // ✅ 启动协程，在 IO 线程执行耗时任务
            mainScope.launch(Dispatchers.IO) {
                try {
                    // 模拟耗时计算
                    delay(2000) 
                    val calculationResult = performHeavyTask()
                    
                    // ✅ 切换回主线程返回结果给 Flutter
                    withContext(Dispatchers.Main) {
                        result.success(calculationResult)
                    }
                } catch (e: Exception) {
                    withContext(Dispatchers.Main) {
                        result.error("CALC_ERROR", e.message, null)
                    }
                }
            }
        }
        else -> result.notImplemented()
    }
}

private fun performHeavyTask(): Int {
    // 模拟复杂逻辑
    return 42
}

注意：务必记得在 onDestroy 中取消 mainScope，防止内存泄漏。

---

5. 🔥 终极方案：Texture 共享内存（针对视频/相机/游戏画面）

如果你需要在 Flutter 中显示 Android 原生的 SurfaceView（如摄像头预览、OpenGL 渲染），不要截图传像素，而是使用 TextureRegistry 共享纹理 ID。这是性能最高的方式，实现了真正的零拷贝。

Kotlin 端：注册 Texture

import io.flutter.view.TextureRegistry

private var textureId: Long = -1
private var surfaceTexture: SurfaceTexture? = null

fun registerCameraTexture(registrar: PluginRegistry.Registrar): Long {
    val textureEntry = registrar.textures().createSurfaceTexture()
    surfaceTexture = textureEntry.surfaceTexture()
    textureId = textureEntry.id()
    
    // 将 SurfaceTexture 绑定到你的 Camera 或 OpenGL 上下文
    // camera.setPreviewTexture(surfaceTexture)
    
    return textureId
}

Flutter 端：显示 Texture

class CameraPreview extends StatefulWidget {
  @override
  _CameraPreviewState createState() => _CameraPreviewState();
}

class _CameraPreviewState extends State<CameraPreview> {
  int _textureId = -1;

  @override
  void initState() {
    super.initState();
    _initCamera();
  }

  Future<void> _initCamera() async {
    // 调用原生方法获取 Texture ID
    final int id = await NativeBridge._channel.invokeMethod('registerCameraTexture');
    setState(() {
      _textureId = id;
    });
  }

  @override
  Widget build(BuildContext context) {
    if (_textureId == -1) {
      return Center(child: CircularProgressIndicator());
    }
    // ✅ 直接使用 Texture Widget，性能极佳
    return Texture(textureId: _textureId);
  }
}