Flutter插件开发：原生对象访问与数据转换策略

本文探讨了在Flutter插件中访问原生平台（Android/iOS）复杂对象的方法。重点介绍了通过MethodChannel进行数据交互时，如何有效地处理原生对象。文章对比了直接传递对象引用和使用数据映射（Map）进行数据转换两种方案，并提供了相应的代码示例，帮助开发者选择最适合自身需求的方案，实现Flutter与原生平台之间的高效通信。

在开发Flutter插件时，经常需要访问原生平台（Android/iOS）的特定对象，尤其是那些复杂的、继承自多个类的对象。直接在Dart端重新实现这些原生对象通常是不现实的，因此需要在Flutter和原生平台之间找到一种有效的数据交互方式。本文将探讨两种主要的方案：直接传递对象引用和使用数据映射（Map）进行数据转换，并分析它们的优缺点。

方案一：传递原生对象引用

这种方案的核心思想是在原生平台创建对象实例后，将该实例的引用（例如，内存地址）传递给Dart端。Dart端保存这个引用，并在后续调用原生方法时，将该引用传递回去，原生平台根据引用找到对应的对象实例，执行相应操作。

示例代码（基于问题中的代码）：

Dart端：

class Peripheral {
  late String _objectReference;
  late String _localName, _uuid;

  Peripheral({required String localName, required String uuid}) {
    _uuid = uuid;
    _localName = localName;
    _newPeripheralInstance(localName, uuid);
  }


  Future<void> _newPeripheralInstance(String localName, String uuid) async {
    _objectReference = (await PeripheralPlatform.instance.newPeripheralInstance(localName, uuid))!;
    return;
  }

  String get objectReference => _objectReference;

  Future<String?> getModelName() async {
    return PeripheralPlatform.instance.getModelName(_objectReference);
  }

  Future<String?> getUuid() async {
    return PeripheralPlatform.instance.getUuid(_objectReference);
  }
}

abstract class PeripheralPlatform {
  static PeripheralPlatform get instance => _instance;

  static late PeripheralPlatform _instance;

  static set instance(PeripheralPlatform instance) {
    _instance = instance;
  }

  Future<String?> newPeripheralInstance(String localName, String uuid) {
    throw UnimplementedError('newPeripheralInstance() has not been implemented.');
  }

  Future<String?> getModelName(String peripheralReference) {
    throw UnimplementedError('getModelName() has not been implemented.');
  }

  Future<String?> getUuid(String peripheralReference) {
    throw UnimplementedError('getUuid() has not been implemented.');
  }
}

class MethodChannelPeripheral extends PeripheralPlatform {
  /// The method channel used to interact with the native platform.
  static const MethodChannel methodChannel = MethodChannel('channel');

  @override
  Future<String?> newPeripheralInstance(String localName, String uuid) async {
    String? instance = await methodChannel.invokeMethod<String>('Peripheral-newPeripheralInstance',  <String, String>{
      'localName': localName,
      'uuid': uuid
    });
    return instance;
  }

  @override
  Future<String?> getModelName(String peripheralReference) async {
    return await methodChannel.invokeMethod<String>('Peripheral-getModelName', <String, String>{
      'peripheralReference': peripheralReference
    });
  }

  @override
  Future<String?> getUuid(String peripheralReference) async {
    return await methodChannel.invokeMethod<String>('Peripheral-getUuid', <String, String>{
      'peripheralReference': peripheralReference
    });
  }
}

Android端（Java）：

import io.flutter.plugin.common.MethodCall;
import io.flutter.plugin.common.MethodChannel;

import java.util.HashMap;
import java.util.Map;

public class PluginPeripheral {
  private static Map<String, Peripheral> peripheralMap = new HashMap<>();

  public static void handleMethodCall(String method, MethodCall call, MethodChannel.Result result) {
    method = method.replace("Peripheral-", "");
    switch (method) {
      case "newPeripheralInstance":
        newPeripheralInstance(call, result);
        break;
      case "getModelName":
        getModelName(call, result);
        break;
      case "getUuid":
        getUuid(call, result);
        break;
      default:
        result.notImplemented();
        break;
    }
  }

  private static void newPeripheralInstance(MethodCall call, MethodChannel.Result result) {
    if (call.hasArgument("uuid") && call.hasArgument("localName")) {
      String uuid = call.argument("uuid");
      String localName = call.argument("localName");
      if (localName == null || uuid == null) {
        result.error("Missing argument", "Missing argument 'uuid' or 'localName'", null);
        return;
      }
      Peripheral peripheral = new Peripheral(localName, uuid);
      peripheralMap.put(peripheral.toString(), peripheral);
      result.success(peripheral.toString());
    }
  }

  private static void getModelName(MethodCall call, MethodChannel.Result result) {
    if (call.hasArgument("peripheralReference")) {
      String peripheralString = call.argument("peripheralReference");
      if (peripheralString == null) {
        result.error("Missing argument", "Missing argument 'peripheral'", null);
        return;
      }
      Peripheral peripheral = peripheralMap.get(peripheralString);
      if (peripheral == null) {
        result.error("Invalid peripheral", "Invalid peripheral", null);
        return;
      }
      result.success(peripheral.getModelName());
    } else {
      result.error("Missing argument", "Missing argument 'peripheralReference'", null);
    }
  }

  private static void getUuid(MethodCall call, MethodChannel.Result result) {
    if (call.hasArgument("peripheralReference")) {
      String peripheralString = call.argument("peripheralReference");
      if (peripheralString == null) {
        result.error("Missing argument", "Missing argument 'peripheral'", null);
        return;
      }
      Peripheral peripheral = peripheralMap.get(peripheralString);
      if (peripheral == null) {
        result.error("Invalid peripheral", "Invalid peripheral", null);
        return;
      }
      result.success(peripheral.getUuid());
    } else {
      result.error("Missing argument", "Missing argument 'peripheralReference'", null);
    }
  }
}

优点：

• 避免重复实现： 无需在Dart端重新实现原生对象，节省了开发成本。
• 保持原生状态： Dart端操作的是原生对象的真实实例，能够充分利用原生平台的特性和功能。

缺点：

• 内存管理复杂： 需要维护原生对象的生命周期，避免内存泄漏。在上述示例中，使用peripheralMap来存储对象引用，需要手动管理对象的创建和销毁。
• 类型安全问题： Dart端只能通过字符串引用来操作原生对象，缺乏类型安全检查，容易出错。
• 性能开销： 每次调用原生方法都需要进行对象查找，可能存在性能瓶颈。

方案二：数据映射（Map）转换

这种方案将原生对象转换为Map数据结构，通过MethodChannel传递Map数据，Dart端接收到Map数据后，再将其转换为Dart对象。

Programming Helper

AI代码自动生成器，在AI的帮助下更快地编程

下载

示例代码：

Dart端：

class Device {
  String? id;
  String? name;

  Device({this.id, this.name});

  Device.fromMap(Map<String, dynamic> map) {
    id = map['id'];
    name = map['name'];
  }
}

// 调用原生方法，并进行数据转换
Future<Device> requestDevice() async {
  final map = await MethodChannelPeripheral.methodChannel.invokeMethod('requestDevice');
  return Device.fromMap(map.cast<String, dynamic>());
}

Android端（Kotlin）：

data class Device(
    val id: String,
    val name: String?
) {
    fun toMap(): Map<String, Any?> {
        return mapOf(
            "id" to id,
            "name" to name
        )
    }
}

override fun onMethodCall(@NonNull call: MethodCall, @NonNull result: Result) {
    when (call.method) {
        "requestDevice" -> {
            // 获取Device对象
            val device = Device("123", "My Device")
            // 将Device对象转换为Map
            result.success(device.toMap())
        }
        else -> {
            result.notImplemented()
        }
    }
}

优点：

• 类型安全： Dart端可以定义明确的数据类型，进行类型检查，避免类型错误。
• 易于管理： 不需要关心原生对象的生命周期，Dart对象由Dart的垃圾回收机制管理。
• 数据隔离： Dart端操作的是原生数据的副本，避免直接修改原生对象的状态。

缺点：

• 需要进行数据转换： 需要在原生平台和Dart端进行数据转换，增加了开发工作量。
• 可能丢失原生对象的特性： 只能传递基本数据类型，无法传递原生对象的行为和方法。
• 性能开销： 频繁的数据转换可能带来性能损耗。

总结与建议

两种方案各有优缺点，选择哪种方案取决于具体的应用场景和需求。

• 如果原生对象非常复杂，且需要在Dart端频繁操作，建议使用数据映射（Map）转换方案，以保证类型安全和易于管理。
• 如果原生对象只是少量使用，或者需要保持原生状态，可以使用传递原生对象引用方案，但需要注意内存管理和类型安全问题。

在实际开发中，可以结合两种方案的优点，例如，对于一些关键属性，可以使用数据映射进行传递，对于一些复杂操作，可以使用对象引用进行调用。此外，还可以考虑使用序列化/反序列化技术，将原生对象转换为JSON或其他格式的数据，以便在Flutter和原生平台之间进行传递。

无论选择哪种方案，都需要仔细评估其性能影响，并进行充分的测试，以确保Flutter插件的稳定性和可靠性。