Flutter插件访问原生Peripheral对象的实现方案咨询

是否需要在Flutter中实现Peripheral对象？ #

不需要在Dart中完全复刻原生Peripheral的继承结构和内部实现。你只需要创建一个Dart包装类，作为原生Peripheral实例的代理，通过Method Channel与原生层交互即可。这个包装类只需暴露业务所需的方法和属性，无需关心原生对象的内部细节。

当前方案是否合理？ #

你的实现方案是Flutter插件集成原生复杂对象的标准且合理的做法：

• 原生层通过Map存储Peripheral实例，用唯一引用关联Dart与原生对象
• Dart端通过Method Channel传递引用，调用原生方法并获取结果
• 这种方式避免了跨平台传递复杂对象的序列化开销，同时保留了原生对象的状态和行为

优化建议 #

虽然当前方案可行，但可以从以下几点优化：

1. 使用更可靠的实例引用键 #

当前用peripheral.toString()作为Map键存在风险：

• 原生Peripheral的默认toString()可能返回非唯一值（如类名+哈希码，不同实例可能冲突）
• 若原生类重写toString()，可能导致键值变化，无法正确获取实例

优化方案：生成唯一标识符作为键，比如：

// Android端修改newPeripheralInstance方法
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);
        // 生成唯一ID替代toString()
        String instanceId = UUID.randomUUID().toString();
        peripheralMap.put(instanceId, peripheral);
        result.success(instanceId);
    }
}

2. 修复Dart构造函数的异步初始化问题 #

当前Dart构造函数是同步的，但内部调用了异步方法_newPeripheralInstance，可能导致_objectReference未初始化就被使用。

优化方案：改用工厂构造函数返回Future：

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

  // 私有构造函数
  Peripheral._({required String localName, required String uuid, required String objectReference}) {
    _uuid = uuid;
    _localName = localName;
    _objectReference = objectReference;
  }

  // 工厂构造函数，返回Future确保初始化完成
  static Future<Peripheral> create({required String localName, required String uuid}) async {
    final objectReference = await PeripheralPlatform.instance.newPeripheralInstance(localName, uuid)!;
    return Peripheral._(localName: localName, uuid: uuid, objectReference: objectReference);
  }

  String get objectReference => _objectReference;

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

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

使用方式：

var peripheral = await Peripheral.create(localName: "test", uuid: "xxx-xxx-xxx");

3. 添加内存管理（避免内存泄漏） #

当Dart端的Peripheral对象不再使用时，需通知原生层移除对应实例，防止内存泄漏。

步骤：

1. Dart类添加dispose方法：

Future<void> dispose() async {
  await PeripheralPlatform.instance.disposePeripheral(_objectReference);
}

2. 原生层添加处理逻辑：

// Android端新增dispose方法
private static void disposePeripheral(MethodCall call, MethodChannel.Result result) {
  String instanceId = call.argument("peripheralReference");
  if (instanceId != null) {
    peripheralMap.remove(instanceId);
    result.success(null);
  } else {
    result.error("Missing argument", "Missing 'peripheralReference'", null);
  }
}

4. 同步iOS端实现 #

确保iOS端采用相同模式：

• 用Dictionary存储Peripheral实例
• 生成唯一ID作为键
• 实现对应的Method Channel方法处理逻辑

总结 #

你的核心思路是正确的，通过上述优化可以提升方案的可靠性和健壮性。这种代理模式是Flutter集成原生复杂对象的常用手段，既能保留原生SDK的功能，又能提供简洁的Dart API。

内容的提问来源于stack exchange，提问作者Simon B