混合开发与平台集成：原生模块集成方案

原创已于 2025-04-30 09:10:41 修改 · 1.1k 阅读

27 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#android #flutter #ios

于 2025-04-30 09:03:53 首次发布

Flutter开发系统化学习指南专栏收录该内容

26 篇文章

订阅专栏

混合开发与平台集成：平台通道与原生模块集成

基础概念

什么是平台通道？

Platform Channel（平台通道）是Flutter提供的一种机制，用于Flutter代码和原生平台（iOS/Android）代码之间的通信。通过平台通道，Flutter可以调用原生平台的API，实现诸如蓝牙通信、地理定位、相机访问等需要原生支持的功能。

平台通道的类型

Flutter提供了三种类型的平台通道：

MethodChannel
- 用于方法调用，支持异步操作
- 适用于一次性请求和响应场景
- 例如：调用原生相机拍照、获取设备信息等
EventChannel
- 用于事件流通信
- 适用于持续性的数据流传输
- 例如：传感器数据监听、蓝牙状态变化等
BasicMessageChannel
- 用于基础消息传递
- 支持自定义消息编解码器
- 适用于需要双向通信的场景

数据编解码

Flutter与原生平台之间的数据传递需要经过编解码，支持的数据类型包括：

基础类型：null、bool、int、double、String
复合类型：List、Map
特殊类型：Uint8List、Int32List、Int64List、Float64List

实战案例

案例一：蓝牙通信实现

项目需求

实现一个基于Flutter的蓝牙通信应用，要求：

搜索并显示周围的蓝牙设备
连接选中的蓝牙设备
与设备进行数据通信
监听设备连接状态

代码实现

1. Flutter端代码

// 创建MethodChannel用于方法调用
static const MethodChannel _methodChannel = MethodChannel('com.example.bluetooth/method');

// 创建EventChannel用于监听蓝牙状态
static const EventChannel _eventChannel = EventChannel('com.example.bluetooth/event');

// 蓝牙管理类
class BluetoothManager {
  // 搜索蓝牙设备
  Future<List<BluetoothDevice>> scanDevices() async {
    try {
      final List<dynamic> result = await _methodChannel.invokeMethod('scanDevices');
      return result.map((e) => BluetoothDevice.fromMap(e)).toList();
    } catch (e) {
      print('扫描设备失败：$e');
      return [];
    }
  }

  // 连接设备
  Future<bool> connectDevice(String deviceId) async {
    try {
      final bool result = await _methodChannel.invokeMethod('connectDevice', {
        'deviceId': deviceId,
      });
      return result;
    } catch (e) {
      print('连接设备失败：$e');
      return false;
    }
  }

  // 发送数据
  Future<bool> sendData(String data) async {
    try {
      final bool result = await _methodChannel.invokeMethod('sendData', {
        'data': data,
      });
      return result;
    } catch (e) {
      print('发送数据失败：$e');
      return false;
    }
  }

  // 监听蓝牙状态
  Stream<BluetoothState> get stateStream {
    return _eventChannel
        .receiveBroadcastStream()
        .map((event) => BluetoothState.fromMap(event));
  }
}

2. Android端代码

class BluetoothPlugin: FlutterPlugin, MethodCallHandler, EventChannel.StreamHandler {
    private lateinit var methodChannel: MethodChannel
    private lateinit var eventChannel: EventChannel
    private var eventSink: EventChannel.EventSink? = null
    private val bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()

    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
        // 注册MethodChannel
        methodChannel = MethodChannel(binding.binaryMessenger, "com.example.bluetooth/method")
        methodChannel.setMethodCallHandler(this)

        // 注册EventChannel
        eventChannel = EventChannel(binding.binaryMessenger, "com.example.bluetooth/event")
        eventChannel.setStreamHandler(this)
    }

    override fun onMethodCall(call: MethodCall, result: Result) {
        when (call.method) {
            "scanDevices" -> {
                // 实现扫描设备逻辑
                val devices = bluetoothAdapter?.bondedDevices?.map {
                    mapOf(
                        "name" to it.name,
                        "address" to it.address
                    )
                }
                result.success(devices?.toList())
            }
            "connectDevice" -> {
                // 实现连接设备逻辑
                val deviceId = call.argument<String>("deviceId")
                // 连接逻辑实现...
                result.success(true)
            }
            "sendData" -> {
                // 实现发送数据逻辑
                val data = call.argument<String>("data")
                // 发送数据逻辑实现...
                result.success(true)
            }
            else -> result.notImplemented()
        }
    }

    override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
        eventSink = events
        // 开始监听蓝牙状态变化
        // 状态变化时调用 eventSink?.success(newState)
    }

    override fun onCancel(arguments: Any?) {
        eventSink = null
    }
}

3. iOS端代码

class BluetoothPlugin: NSObject, FlutterPlugin {
    private var eventSink: FlutterEventSink?
    private let centralManager = CBCentralManager()
    
    static func register(with registrar: FlutterPluginRegistrar) {
        // 注册MethodChannel
        let methodChannel = FlutterMethodChannel(
            name: "com.example.bluetooth/method",
            binaryMessenger: registrar.messenger())
        let instance = BluetoothPlugin()
        registrar.addMethodCallDelegate(instance, channel: methodChannel)
        
        // 注册EventChannel
        let eventChannel = FlutterEventChannel(
            name: "com.example.bluetooth/event",
            binaryMessenger: registrar.messenger())
        eventChannel.setStreamHandler(instance)
    }
    
    func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
        switch call.method {
        case "scanDevices":
            // 实现扫描设备逻辑
            let devices = centralManager.retrieveConnectedPeripherals(withServices: [])
            let deviceList = devices.map { [
                "name": $0.name ?? "",
                "identifier": $0.identifier.uuidString
            ] }
            result(deviceList)
            
        case "connectDevice":
            guard let args = call.arguments as? [String: Any],
                  let deviceId = args["deviceId"] as? String else {
                result(FlutterError(code: "INVALID_ARGUMENT",
                                   message: "Invalid device ID",
                                   details: nil))
                return
            }
            // 连接逻辑实现...
            result(true)
            
        case "sendData":
            guard let args = call.arguments as? [String: Any],
                  let data = args["data"] as? String else {
                result(FlutterError(code: "INVALID_ARGUMENT",
                                   message: "Invalid data",
                                   details: nil))
                return
            }
            // 发送数据逻辑实现...
            result(true)
            
        default:
            result(FlutterMethodNotImplemented)
        }
    }
}

// MARK: - FlutterStreamHandler
extension BluetoothPlugin: FlutterStreamHandler {
    func onListen(withArguments arguments: Any?,
                  eventSink: @escaping FlutterEventSink) -> FlutterError? {
        self.eventSink = eventSink
        // 开始监听蓝牙状态变化
        // 状态变化时调用 eventSink(newState)
        return nil
    }
    
    func onCancel(withArguments arguments: Any?) -> FlutterError? {
        eventSink = nil
        return nil
    }
}

案例二：高德地图SDK集成

项目配置

Android配置

在android/app/build.gradle中添加依赖：

dependencies {
    implementation 'com.amap.api:3dmap:latest.integration'
}

在AndroidManifest.xml中添加权限和Key配置：

<manifest>
    <application>
        <meta-data
            android:name="com.amap.api.v2.apikey"
            android:value="your_key_here"/>
    </application>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
</manifest>

iOS配置

在ios/Podfile中添加依赖：

target 'Runner' do
  pod 'AMap3DMap'
end

在Info.plist中添加权限配置：

<key>NSLocationWhenInUseUsageDescription</key>
<string>需要定位权限</string>

代码实现

1. Flutter端代码

// lib/channels/map_channel.dart
class MapChannel {
  static const MethodChannel _channel = MethodChannel('com.example.map');
  
  static Future<void> initMap() async {
    try {
      await _channel.invokeMethod('initMap');
    } catch (e) {
      print('初始化地图失败：$e');
    }
  }
  
  static Future<Map<String, double>> getCurrentLocation() async {
    try {
      final result = await _channel.invokeMethod('getCurrentLocation');
      return {
        'latitude': result['latitude'],
        'longitude': result['longitude']
      };
    } catch (e) {
      print('获取位置失败：$e');
      return {};
    }
  }
}

2. Android端代码

class MapPlugin: MethodCallHandler {
    private lateinit var mapView: MapView
    
    override fun onMethodCall(call: MethodCall, result: Result) {
        when (call.method) {
            "initMap" -> {
                // 初始化地图
                mapView = MapView(context)
                result.success(null)
            }
            "getCurrentLocation" -> {
                // 获取当前位置
                val location = mapView.map.myLocation
                result.success(mapOf(
                    "latitude" to location.latitude,
                    "longitude" to location.longitude
                ))
            }
            else -> result.notImplemented()
        }
    }
}

3. iOS端代码

class MapPlugin: NSObject, FlutterPlugin {
    private var mapView: MAMapView?
    
    static func register(with registrar: FlutterPluginRegistrar) {
        let channel = FlutterMethodChannel(name: "com.example.map",
                                         binaryMessenger: registrar.messenger())
        let instance = MapPlugin()
        registrar.addMethodCallDelegate(instance, channel: channel)
    }
    
    func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
        switch call.method {
        case "initMap":
            mapView = MAMapView()
            result(nil)
        case "getCurrentLocation":
            if let location = mapView?.userLocation.coordinate {
                result([
                    "latitude": location.latitude,
                    "longitude": location.longitude
                ])
            } else {
                result(FlutterError(code: "UNAVAILABLE",
                                   message: "Location not available",
                                   details: nil))
            }
        default:
            result(FlutterMethodNotImplemented)
        }
    }
}