Flutter插件开发：原生对象访问与数据转换策略-java教程-PHP中文网

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

DDD

发布： 2025-10-04 10:28:02

原创

662人浏览过

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对象。

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()
        }
    }
}

登录后复制

优点：