Flutter平台对象通信插件platform_object_channel_interface的使用

platform_object_channel_interface 是一个用于在 Flutter 和原生平台（Android 和 iOS）之间进行对象通信的插件。它允许你在 Flutter 和原生代码之间传递复杂的对象，而不仅仅是简单的数据类型。这个插件通常用于需要与原生平台进行深度集成的场景。

安装插件

首先，你需要在 pubspec.yaml 文件中添加 platform_object_channel_interface 插件的依赖：

dependencies:
  flutter:
    sdk: flutter
  platform_object_channel_interface: ^1.0.0

然后运行 flutter pub get 来安装插件。

在 Flutter 中使用

1. 创建 PlatformObjectChannel

在 Flutter 中，你可以通过 PlatformObjectChannel 来与原生平台进行通信。首先，你需要创建一个 PlatformObjectChannel 实例：

import 'package:platform_object_channel_interface/platform_object_channel_interface.dart';

final platformChannel = PlatformObjectChannel('com.example.myapp/channel_name');

2. 发送消息到原生平台

你可以使用 invokeMethod 方法向原生平台发送消息，并传递一个对象：

final response = await platformChannel.invokeMethod('method_name', {'key': 'value'});
print('Response from native: $response');

3. 接收来自原生平台的消息

你可以通过设置 setMethodCallHandler 来接收来自原生平台的消息：

platformChannel.setMethodCallHandler((methodCall) async {
  print('Method call from native: ${methodCall.method}');
  print('Arguments: ${methodCall.arguments}');
  return 'Response from Flutter';
});

在原生平台中使用

1. Android

在 Android 中，你需要创建一个 MethodChannel 来处理来自 Flutter 的消息。首先，在 MainActivity 中设置 MethodChannel：

import io.flutter.plugin.common.MethodChannel;
import io.flutter.plugin.common.MethodChannel.MethodCallHandler;
import io.flutter.plugin.common.MethodChannel.Result;
import io.flutter.plugin.common.PluginRegistry.Registrar;

public class MainActivity extends FlutterActivity {
  private static final String CHANNEL = "com.example.myapp/channel_name";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    new MethodChannel(getFlutterView(), CHANNEL).setMethodCallHandler(
      new MethodCallHandler() {
        @Override
        public void onMethodCall(MethodCall call, Result result) {
          if (call.method.equals("method_name")) {
            // Handle method call
            String response = "Response from Android";
            result.success(response);
          } else {
            result.notImplemented();
          }
        }
      }
    );
  }
}

2. iOS

在 iOS 中，你需要在 AppDelegate 中设置 FlutterMethodChannel：

import UIKit
import Flutter

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController
    let channel = FlutterMethodChannel(name: "com.example.myapp/channel_name", binaryMessenger: controller.binaryMessenger)
    channel.setMethodCallHandler({
      (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
      if call.method == "method_name" {
        // Handle method call
        let response = "Response from iOS"
        result(response)
      } else {
        result(FlutterMethodNotImplemented)
      }
    })
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
}

传递复杂对象

platform_object_channel_interface 允许你传递复杂的对象。你可以通过将对象序列化为 Map 或 List 来传递它们，然后在原生平台中反序列化。

例如，在 Flutter 中传递一个自定义对象：

class MyCustomObject {
  final String name;
  final int age;

  MyCustomObject(this.name, this.age);

  Map<String, dynamic> toMap() {
    return {
      'name': name,
      'age': age,
    };
  }
}

final customObject = MyCustomObject('John', 30);
final response = await platformChannel.invokeMethod('method_name', customObject.toMap());

在 Android 中接收并处理这个对象：

if (call.method.equals("method_name")) {
  Map<String, Object> args = call.arguments();
  String name = (String) args.get("name");
  int age = (int) args.get("age");
  // Handle the object
  result.success("Response from Android");
}

在 iOS 中接收并处理这个对象：

if call.method == "method_name" {
  let args = call.arguments as? [String: Any]
  let name = args?["name"] as? String
  let age = args?["age"] as? Int
  // Handle the object
  result("Response from iOS")
}