Flutter与iOS和Android原生页面交互

一、Flutter 与原生页面交互的重要性和应用场景

Flutter 是一个由 Google 开发的开源框架，用于创建跨平台的移动、Web 和桌面应用程序。Flutter 允许开发者利用一套代码库为 Android 和 iOS 等平台构建美观、高性能的应用程序。然而，尽管 Flutter 提供了丰富的组件和库，某些环境下，开发者大概仍必要利用平台特有的功能或集成现有的原生页面和服务。
在以下场景中，Flutter 与原生页面交互显得尤为重要：

• 利用现有原生代码：在项目中大概已经存在大量的原生代码，重新用 Flutter 实现大概不现实或本钱过高。
  
• 调用平台特有的API：一些平台特有的API（如支付、地图等）只能通过原生代码访问。
  
• 集成第三方原生库：一些第三方库只提供原生的接口，必要通过原生代码来集成。
  
• 性能关键任务：对于一些性能敏感的任务，原生代码往往可以提供更好的性能表现。
  
• 遵循平台筹划规范：偶尔为了保持应用的一致性，必要利用原生组件来服从特定平台的筹划规范。
  

通过与原生页面的交互，Flutter 开发者可以充分利用平台的本事，同时保持应用的流畅性和用户体验的一致性。

二、根本概念

1.平台通道（Platform Channels）先容

平台通道是Flutter中一个强大的机制，它允许Flutter与宿主平台（如Android和iOS）举行数据和任务的双向通讯。这种机制办理了Flutter无法直接调用平台特定API的限定，使得Flutter应用能够实现原平生台的功能。
(1).通道的工作原理

平台通道通过利用一个消息通报的系统工作，该系统包罗以下三个关键概念：

• 消息：通报的数据单元，可以是简朴的字符串、数字或者更复杂的序列化数据结构。
  
• 编解码器：负责消息的序列化与反序列化。Flutter提供了几种尺度的编解码器，例如JSONMessageCodec、StandardMessageCodec、StringCodec和BinaryCodec。
  
• 通道：毗连Flutter和原平生台代码的通讯通道。
  

(2).通道的种类

Flutter提供了三种类型的平台通道，每种通道都适合差别的应用场景：
MethodChannel用于通报方法调用及其响应。方法调用是单次的，通常用于执行原生操作并获取结果。
EventChannel用于创建一个数据流，它允许原生代码发送连续的变乱数据给Flutter。这适合于监听原生端的变乱或数据变化，如传感器数据或用户位置更新。
BasicMessageChannel用于通报没有固定响应的消息，支持自定义的编解码器。这适合于双向通讯，比如状态同步或数据共享。
(3).序列化机制

由于消息必要在Flutter和原生代码之间通报，以是它们必要被序列化（转换为字节序列）和反序列化。Flutter框架提供了几个内置的编解码器来处理惩罚常见的数据类型，开发者也可以自定义编解码器。
(4).平台通道的利用

利用平台通道时，通常必要在Flutter端和原生端同时举行代码编写。
以下是一个简朴的MethodChannel利用示例：
Flutter端

1. import 'package:flutter/services.dart';
3. class BatteryLevel {
4.   static const MethodChannel _channel =
5.       MethodChannel('com.example.battery');
7.   static Future<int> getBatteryLevel() async {
8.     final int batteryLevel = await _channel.invokeMethod('getBatteryLevel');
9.     return batteryLevel;
10.   }
11. }

复制代码

Android端（Kotlin）

1. class MainActivity: FlutterActivity() {
2.     private val CHANNEL = "com.example.battery"
4.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
5.         super.configureFlutterEngine(flutterEngine)
6.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
7.             call, result ->
8.             if (call.method == "getBatteryLevel") {
9.                 val batteryLevel = getBatteryLevel()
11.                 if (batteryLevel != -1) {
12.                     result.success(batteryLevel)
13.                 } else {
14.                     result.error("UNAVAILABLE", "Battery level not available.", null)
15.                 }
16.             } else {
17.                 result.notImplemented()
18.             }
19.         }
20.     }
22.     private fun getBatteryLevel(): Int {
23.         val batteryLevel: Int
24.         if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
25.             val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager
26.             batteryLevel = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
27.         } else {
28.             val intent = ContextWrapper(applicationContext).registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED))
29.             batteryLevel = intent!!.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) * 100 / intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
30.         }
32.         return batteryLevel
33.     }
34. }

复制代码

iOS端（Swift）

1. import Flutter
2. import UIKit
4. @UIApplicationMain
5. @objc class AppDelegate: FlutterAppDelegate {
6.   private let batteryChannel = "com.example.battery"
8.   override func application(
9.     _ application: UIApplication,
10.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
11.   ) -> Bool {
12.     GeneratedPluginRegistrant.register(with: self)
13.    
14.     let controller: FlutterViewController = window?.rootViewController as! FlutterViewController
15.     let methodChannel = FlutterMethodChannel(name: batteryChannel,
16.                                               binaryMessenger: controller.binaryMessenger)
17.     methodChannel.setMethodCallHandler({
18.       [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
19.       // Handle battery messages.
20.       guard call.method == "getBatteryLevel" else {
21.         result(FlutterMethodNotImplemented)
22.         return
23.       }
24.       self?.receiveBatteryLevel(result: result)
25.     })
27.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
28.   }
30.   private func receiveBatteryLevel(result: FlutterResult) {
31.     let device = UIDevice.current
32.     device.isBatteryMonitoringEnabled = true
33.     if device.batteryState == UIDevice.BatteryState.unknown {
34.       result(FlutterError(code: "UNAVAILABLE",
35.                           message: "Battery level not available.",
36.                           details: nil))
37.     } else {
38.       result(Int(device.batteryLevel * 100))
39.     }
40.   }
41. }

复制代码

2.Flutter 平台通道比力及示例

在Flutter中，MethodChannel、EventChannel和BasicMessageChannel是三种差别的平台通道，用于实现Dart代码和原平生台代码之间的通讯。
MethodChannel

MethodChannel通常用于发送方法调用哀求，并接收单次响应。它适合于执行原生操作并获取结果的场景。
Flutter端

1. import 'package:flutter/services.dart';
3. // 创建MethodChannel实例
4. const MethodChannel methodChannel = MethodChannel('com.example.channel/method');
6. // 调用原生方法并获取电池电量
7. Future<int> getBatteryLevel() async {
8.   try {
9.     // 调用原生平台的'getBatteryLevel'方法
10.     final int result = await methodChannel.invokeMethod('getBatteryLevel');
11.     return result;
12.   } on PlatformException catch (e) {
13.     // 处理异常情况
14.     return -1;
15.   }
16. }

复制代码

Android端（Kotlin）

1. import io.flutter.embedding.android.FlutterActivity
2. import io.flutter.embedding.engine.FlutterEngine
3. import io.flutter.plugin.common.MethodChannel
5. class MainActivity: FlutterActivity() {
6.     // 定义通道名称
7.     private val CHANNEL = "com.example.channel/method"
9.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
10.         super.configureFlutterEngine(flutterEngine)
11.         // 创建MethodChannel实例并设置方法调用处理器
12.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
13.             if (call.method == "getBatteryLevel") {
14.                 // 执行获取电池电量的操作，并将结果返回给Flutter端
15.                 val batteryLevel = getBatteryLevel()
16.                 if (batteryLevel != -1) {
17.                     result.success(batteryLevel)
18.                 } else {
19.                     result.error("UNAVAILABLE", "Battery level not available.", null)
20.                 }
21.             } else {
22.                 result.notImplemented()
23.             }
24.         }
25.     }
27.     // 模拟获取电池电量的函数
28.     private fun getBatteryLevel(): Int {
29.         // 这里只是一个示例，实际获取电池电量的方法与此不同
30.         return 100 // 假设电池电量是100%
31.     }
32. }

复制代码

iOS端（Swift）

1. import Flutter
2. import UIKit
4. @UIApplicationMain
5. @objc class AppDelegate: FlutterAppDelegate {
6.   // 定义通道名称
7.   private let methodChannelName = "com.example.channel/method"
9.   override func application(
10.     _ application: UIApplication,
11.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
12.   ) -> Bool {
13.     GeneratedPluginRegistrant.register(with: self)
14.    
15.     guard let controller = window?.rootViewController as? FlutterViewController else {
16.       fatalError("rootViewController is not type FlutterViewController")
17.     }
18.    
19.     // 创建MethodChannel实例并设置方法调用处理器
20.     let methodChannel = FlutterMethodChannel(name: methodChannelName,
21.                                              binaryMessenger: controller.binaryMessenger)
22.     methodChannel.setMethodCallHandler({
23.       [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
24.       // 检查方法名并执行相应操作
25.       if call.method == "getBatteryLevel" {
26.         // 执行获取电池电量的操作，并将结果返回给Flutter端
27.         self?.receiveBatteryLevel(result: result)
28.       } else {
29.         result(FlutterMethodNotImplemented)
30.       }
31.     })
32.    
33.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
34.   }
35.   
36.   private func receiveBatteryLevel(result: FlutterResult) {
37.     // 这里只是一个示例，实际获取电池电量的方法与此不同
38.     result(100) // 假设电池电量是100%
39.   }
40. }

复制代码

EventChannel

EventChannel用于数据流（event streams），可以用来监听原生端发出的变乱。例如，原生端的传感器数据或数据库更新。
Flutter端

1. import 'package:flutter/services.dart';
3. // 创建EventChannel实例
4. const EventChannel eventChannel = EventChannel('com.example.channel/stream');
6. // 监听来自原生平台的事件流
7. void listenToNativeEvents() {
8.   eventChannel.receiveBroadcastStream().listen((event) {
9.     // 处理原生平台发送的数据
10.     print('Received event: $event');
11.   }, onError: (error) {
12.     // 处理错误
13.     print('Received error: ${error.message}');
14.   });
15. }

复制代码

Android端（Kotlin）

1. import io.flutter.embedding.android.FlutterActivity
2. import io.flutter.embedding.engine.FlutterEngine
3. import io.flutter.plugin.common.EventChannel
4. import java.util.*
6. class MainActivity : FlutterActivity() {
7.     // 定义通道名称
8.     private val CHANNEL = "com.example.channel/stream"
10.     // 模拟传感器数据流
11.     private val sensorDataStream = Timer()
13.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
14.         super.configureFlutterEngine(flutterEngine)
15.         // 创建EventChannel实例并设置事件流处理器
16.         EventChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setStreamHandler(
17.             object : EventChannel.StreamHandler {
18.                 override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
19.                     // 设置定时器，模拟传送传感器数据
20.                     sensorDataStream.schedule(object : TimerTask() {
21.                         override fun run() {
22.                             // 模拟事件数据，这里发送当前时间戳
23.                             events?.success(System.currentTimeMillis())
24.                         }
25.                     }, 0, 1000)
26.                 }
28.                 override fun onCancel(arguments: Any?) {
29.                     // 取消事件流
30.                     sensorDataStream.cancel()
31.                 }
32.             }
33.         )
34.     }
35. }

复制代码

iOS端（Swift）

1. import Flutter
2. import UIKit
4. class StreamHandler: NSObject, FlutterStreamHandler {
5.     private var eventSink: FlutterEventSink?
6.     private var timer: Timer?
8.     func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? {
9.         eventSink = events
10.         // 设置定时器，模拟传送传感器数据
11.         timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
12.             // 模拟事件数据，这里发送当前时间戳
13.             events(Date().timeIntervalSince1970 * 1000)
14.         }
15.         return nil
16.     }
18.     func onCancel(withArguments arguments: Any?) -> FlutterError? {
19.         // 取消定时器
20.         timer?.invalidate()
21.         timer = nil
22.         eventSink = nil
23.         return nil
24.     }
25. }
27. @UIApplicationMain
28. @objc class AppDelegate: FlutterAppDelegate {
29.     // 定义通道名称
30.     private let streamChannelName = "com.example.channel/stream"
32.     override func application(
33.         _ application: UIApplication,
34.         didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
35.     ) -> Bool {
36.         GeneratedPluginRegistrant.register(with: self)
37.         
38.         let controller: FlutterViewController = window?.rootViewController as! FlutterViewController
39.         // 创建EventChannel实例并设置事件流处理器
40.         let eventChannel = FlutterEventChannel(name: streamChannelName, binaryMessenger: controller.binaryMessenger)
41.         let streamHandler = StreamHandler()
42.         eventChannel.setStreamHandler(streamHandler)
43.         
44.         return super.application(application, didFinishLaunchingWithOptions: launchOptions)
45.     }
46. }

复制代码

BasicMessageChannel

BasicMessageChannel 允许发送和接收字符串和半结构化信息，实用于自定义编码和协议，或者必要频仍通讯但数据量不大的场景。
Flutter端

1. import 'package:flutter/services.dart';
3. // 创建BasicMessageChannel实例
4. BasicMessageChannel<String> basicMessageChannel =
5.     BasicMessageChannel<String>('com.example.channel/basic', StringCodec());
7. // 向原生发送消息
8. Future<void> sendMessage(String message) async {
9.   String response = await basicMessageChannel.send(message);
10.   print('Received response: $response');
11. }
13. // 接收来自原生的消息
14. void receiveMessages() {
15.   basicMessageChannel.setMessageHandler((String message) async {
16.     print('Received message: $message');
17.     return 'Received!';
18.   });
19. }

复制代码

Android端（Kotlin）

1. import io.flutter.embedding.android.FlutterActivity
2. import io.flutter.embedding.engine.FlutterEngine
3. import io.flutter.plugin.common.BasicMessageChannel
4. import io.flutter.plugin.common.StringCodec
6. class MainActivity: FlutterActivity() {
7.     private val CHANNEL = "com.example.channel/basic"
9.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
10.         super.configureFlutterEngine(flutterEngine)
11.         // 创建BasicMessageChannel实例
12.         val messageChannel = BasicMessageChannel<String>(flutterEngine.dartExecutor.binaryMessenger, CHANNEL, StringCodec.INSTANCE)
14.         // 设置消息接收器
15.         messageChannel.setMessageHandler { message, reply ->
16.             // 在这里处理从Flutter接收到的消息
17.             println("Received message: $message")
18.             // 回复消息给Flutter端
19.             reply.reply("Echo: $message")
20.         }
21.     }
22. }

复制代码

iOS端（Swift）

1. import Flutter
2. import UIKit
4. @UIApplicationMain
5. @objc class AppDelegate: FlutterAppDelegate {
6.   private let basicMessageChannelName = "com.example.channel/basic"
8.   override func application(
9.     _ application: UIApplication,
10.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
11.   ) -> Bool {
12.     GeneratedPluginRegistrant.register(with: self)
13.    
14.     guard let controller = window?.rootViewController as? FlutterViewController else {
15.       fatalError("rootViewController is not type FlutterViewController")
16.     }
17.    
18.     // 创建BasicMessageChannel实例
19.     let messageChannel = FlutterBasicMessageChannel(name: basicMessageChannelName,
20.                                                     binaryMessenger: controller.binaryMessenger,
21.                                                     codec: FlutterStringCodec.sharedInstance())
22.    
23.     // 设置消息接收器
24.     messageChannel.setMessageHandler { (message: Any?, reply: FlutterReply) in
25.       // 在这里处理从Flutter接收到的消息
26.       if let messageStr = message as? String {
27.         print("Received message: \(messageStr)")
28.         // 回复消息给Flutter端
29.         reply("Echo: \(messageStr)")
30.       }
31.     }
32.    
33.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
34.   }
35. }

复制代码

3.异步编程在平台通道中的应用

在Flutter中，平台通道的调用通常是异步的，这意味着你可以利用async和await关键字来等待原生代码的执行结果而不会壅闭UI线程。
例如，利用MethodChannel哀求电池电量时，你通常会这样做：

1. Future<void> _getBatteryLevel() async {
2.   String batteryLevel;
3.   try {
4.     final int result = await NativeBridge.getBatteryLevel();
5.     batteryLevel = 'Battery level at $result % .';
6.   } on PlatformException {
7.     batteryLevel = 'Failed to get battery level.';
8.   }
9.   print(batteryLevel);
10. }

复制代码

三、设置平台通道

1.定义通道名

我们将设置一个名为 "com.example.channel/method" 的 MethodChannel 平台通道，这个通道将用于Flutter与原平生台（iOS和Android）之间的通讯。

2.在 Flutter端创建MethodChannel

在Flutter端，你必要创建一个 MethodChannel 实例，并通过它发送消息到原平生台。

1. // 导入相关包
2. import 'package:flutter/services.dart';
4. // 定义通道名
5. const platformChannel = MethodChannel('com.example.channel/method');
7. // 调用原生方法
8. Future<void> getNativeData() async {
9.   try {
10.     final String result = await platformChannel.invokeMethod('getNativeData');
11.     print('从原生平台获取的数据：$result');
12.   } on PlatformException catch (e) {
13.     print("调用原生平台方法失败：${e.message}");
14.   }
15. }

复制代码

在上面的代码中，我们定义了一个方法通道名 "com.example.channel/method"，并创建了 MethodChannel 实例。我们定义了一个名为 getNativeData 的函数，该函数调用原平生台的 'getNativeData' 方法，并处理惩罚来自原平生台的响应或异常。

3.在Android（Kotlin）端监听通道

在Android端，我们必要在 MainActivity 中设置 MethodChannel 并定义方法调用的处理惩罚逻辑。

1. // 导入相关包
2. import io.flutter.embedding.android.FlutterActivity
3. import io.flutter.embedding.engine.FlutterEngine
4. import io.flutter.plugin.common.MethodCall
5. import io.flutter.plugin.common.MethodChannel
6. import io.flutter.plugin.common.MethodChannel.MethodCallHandler
8. class MainActivity: FlutterActivity() {
9.     private val CHANNEL = "com.example.channel/method"
11.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
12.         super.configureFlutterEngine(flutterEngine)
14.         // 设置MethodChannel并监听来自Flutter的调用
15.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
16.             // 判断调用的方法名
17.             if (call.method == "getNativeData") {
18.                 // 执行获取数据的逻辑
19.                 val nativeData = "来自Android的数据"
20.                 // 使用result对象发送结果回Flutter
21.                 result.success(nativeData)
22.             } else {
23.                 // 如果方法未实现，返回未实现的错误
24.                 result.notImplemented()
25.             }
26.         }
27.     }
28. }

复制代码

在这段代码中，我们在 MainActivity 类中创建了一个 MethodChannel 实例，然后设置了一个 MethodCallHandler 来监听来自Flutter的方法调用。当Flutter调用 'getNativeData' 方法时，我们返回一些模仿的数据给Flutter。

3.在iOS（Swift）端监听通道

在iOS端，我们在 AppDelegate 中设置 MethodChannel 并处理惩罚方法调用。

1. import UIKit
2. import Flutter
4. @UIApplicationMain
5. @objc class AppDelegate: FlutterAppDelegate {
6.   // 定义通道名 与Flutter端定义的通道名称保持一致
7.   private let channelName = "com.example.channel/method"
9.   override func application(
10.     _ application: UIApplication,
11.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
12.   ) -> Bool {
13.     GeneratedPluginRegistrant.register(with: self)
14.     guard let controller = window?.rootViewController as? FlutterViewController else {
15.       fatalError("rootViewController is not type FlutterViewController")
16.     }
18.     let channel = MethodChannel(name: channelName, binaryMessenger: controller.binaryMessenger)
20.     // 设置监听器以处理来自Flutter的方法调用
21.     channel.setMethodCallHandler {
22.       (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
23.       // 检查方法名以确定执行哪个原生方法
24.       if call.method == "getNativeData" {
25.         // 执行获取数据逻辑
26.         let nativeData = "来自iOS的数据"
27.         // 发送结果回Flutter
28.         result(nativeData)
29.       } else {
30.         // 如果方法未实现，返回未实现的错误
31.         result(FlutterMethodNotImplemented)
32.       }
33.     }
35.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
36.   }
37. }

复制代码

在这段Swift代码中，我们在 AppDelegate 类中同样定义了一个 MethodChannel，并设置了一个闭包作为 MethodCallHandler 来监听Flutter的方法调用。当Flutter哀求 'getNativeData' 方法时，我们返回一串模仿的数据。

四、跳转到原生页面

为了实现Flutter跳转到原生页面的功能，我们必要在三个平台上编写相应的代码：Flutter、iOS和Android。
Flutter端

在Flutter端，我们利用MethodChannel来发起跳转到原生页面的哀求。

1. // 导入必要的包
2. import 'package:flutter/material.dart';
3. import 'package:flutter/services.dart';
5. void main() => runApp(MyApp());
7. class MyApp extends StatelessWidget {
8.   @override
9.   Widget build(BuildContext context) {
10.     return MaterialApp(
11.       home: HomeScreen(),
12.     );
13.   }
14. }
16. class HomeScreen extends StatelessWidget {
17.   // 创建MethodChannel实例，通道名称要与原生端一致
18.   static const platformChannel = MethodChannel('com.example.channel/native');
20.   // 调用原生方法跳转到原生页面的函数
21.   Future<void> openNativeScreen() async {
22.     try {
23.       // 调用原生平台的openNativeScreen方法
24.       await platformChannel.invokeMethod('openNativeScreen');
25.     } on PlatformException catch (e) {
26.       // 如果跳转失败，捕获异常
27.       print("Failed to open native screen: ${e.message}");
28.     }
29.   }
31.   @override
32.   Widget build(BuildContext context) {
33.     return Scaffold(
34.       appBar: AppBar(
35.         title: Text('Flutter Home Screen'),
36.       ),
37.       body: Center(
38.         child: ElevatedButton(
39.           onPressed: openNativeScreen, // 点击按钮时发起跳转
40.           child: Text('Go to Native Screen'),
41.         ),
42.       ),
43.     );
44.   }
45. }

复制代码

在上面的Flutter代码中，我们定义了一个按钮，当用户点击这个按钮时，openNativeScreen函数会通过MethodChannel发起一个名为openNativeScreen的方法调用。

Android端（Kotlin）

在Android端，在MainActivity中监听MethodChannel，并对openNativeScreen方法调用举行处理惩罚，启动一个新的Activity。

1. // MainActivity.kt
2. import android.content.Intent
3. import io.flutter.embedding.android.FlutterActivity
4. import io.flutter.embedding.engine.FlutterEngine
5. import io.flutter.plugin.common.MethodChannel
7. class MainActivity: FlutterActivity() {
8.     private val CHANNEL = "com.example.channel/native"
10.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
11.         super.configureFlutterEngine(flutterEngine)
13.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
14.             if (call.method == "openNativeScreen") {
15.                 // 创建Intent并启动新的Activity
16.                 val intent = Intent(this, NativeActivity::class.java)
17.                 startActivity(intent)
18.                 // 返回成功结果
19.                 result.success(null)
20.             } else {
21.                 result.notImplemented()
22.             }
23.         }
24.     }
25. }

复制代码

1. // NativeActivity.kt
2. import android.os.Bundle
3. import androidx.appcompat.app.AppCompatActivity
5. // 创建新的Activity用于展示原生页面
6. class NativeActivity : AppCompatActivity() {
7.     override fun onCreate(savedInstanceState: Bundle?) {
8.         super.onCreate(savedInstanceState)
9.         // 设置原生页面的布局
10.         setContentView(R.layout.activity_native)
11.     }
12. }

复制代码

在Android项目中，我们还必要在AndroidManifest.xml中注册NativeActivity。

1. <activity android:name=".NativeActivity">
2.     <!-- 配置和其他Activity相关的属性 -->
3. </activity>

复制代码

iOS端（Swift）

在iOS端，在AppDelegate中监听MethodChannel，并对openNativeScreen方法调用举行处理惩罚，启动一个新的UIViewController。

1. import UIKit
2. import Flutter
4. @UIApplicationMain
5. @objc class AppDelegate: FlutterAppDelegate {
6.   private let channelName = "com.example.channel/native"
8.   override func application(
9.     _ application: UIApplication,
10.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
11.   ) -> Bool {
12.     GeneratedPluginRegistrant.register(with: self)
14.     if let controller = window?.rootViewController as? FlutterViewController {
15.       let channel = FlutterMethodChannel(name: channelName, binaryMessenger: controller.binaryMessenger)
17.       channel.setMethodCallHandler { (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
18.         if call.method == "openNativeScreen" {
19.           // 实现UIViewController的跳转逻辑
20.           self.openNativeScreen(from: controller)
21.           result(nil)
22.         } else {
23.           result(FlutterMethodNotImplemented)
24.         }
25.       }
26.     }
28.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
29.   }
31.   private func openNativeScreen(from flutterViewController: FlutterViewController) {
32.     // 创建原生页面的UIViewController
33. let nativeViewController = NativeViewController()
34.     // 从当前FlutterViewController进行页面跳转
35.     flutterViewController.present(nativeViewController, animated: true, completion: nil)
36.   }
37. }

复制代码

1. // NativeViewController.swift
2. import UIKit
4. // 创建一个新的UIViewController子类作为原生页面
5. class NativeViewController: UIViewController {
6.   override func viewDidLoad() {
7.     super.viewDidLoad()
8.     // 设置原生页面的属性，例如背景色
9.     view.backgroundColor = UIColor.white
10.   }
11. }

复制代码

五、从 Flutter 传值给原生页面并得到响应

为了实现从Flutter应用通报数据到原生页面，并在原生页面中接收息争析这些数据，我们必要分别在Flutter、Android和iOS端编写代码。
Flutter端发送数据

1. import 'package:flutter/material.dart';
2. import 'package:flutter/services.dart';
3. import 'dart:convert';
5. void main() {
6.   runApp(MyApp());
7. }
9. class MyApp extends StatelessWidget {
10.   @override
11.   Widget build(BuildContext context) {
12.     return MaterialApp(
13.       home: HomeScreen(),
14.     );
15.   }
16. }
18. class HomeScreen extends StatelessWidget {
19.   // 创建MethodChannel实例，通道名称要与原生端一致
20.   static const platformChannel = MethodChannel('com.example.channel/transfer');
22.   // 向原生页面发送简单数据
23.   Future<void> sendSimpleData() async {
24.     try {
25.       final String response = await platformChannel.invokeMethod('sendSimpleData', {'message': 'Hello from Flutter!'});
26.       print(response); // 打印原生页面返回的响应
27.     } on PlatformException catch (e) {
28.       print("Failed to send simple data: ${e.message}");
29.     }
30.   }
32.   // 向原生页面发送复杂数据（如JSON）
33.   Future<void> sendComplexData() async {
34.     try {
35.       final Map<String, dynamic> complexData = {
36.         'user': {
37.           'id': 1,
38.           'name': 'John Doe',
39.           'email': 'johndoe@example.com',
40.         }
41.       };
42.       final String response = await platformChannel.invokeMethod('sendComplexData', {'data': json.encode(complexData)});
43.       print(response); // 打印原生页面返回的响应
44.     } on PlatformException catch (e) {
45.       print("Failed to send complex data: ${e.message}");
46.     }
47.   }
49.   @override
50.   Widget build(BuildContext context) {
51.     return Scaffold(
52.       appBar: AppBar(
53.         title: Text('Flutter to Native Data Transfer'),
54.       ),
55.       body: Center(
56.         child: Column(
57.           mainAxisAlignment: MainAxisAlignment.center,
58.           children: <Widget>[
59.             ElevatedButton(
60.               onPressed: sendSimpleData,
61.               child: Text('Send Simple Data'),
62.             ),
63.             ElevatedButton(
64.               onPressed: sendComplexData,
65.               child: Text('Send Complex Data'),
66.             ),
67.           ],
68.         ),
69.       ),
70.     );
71.   }
72. }

复制代码

在Flutter端，我们创建了两个函数sendSimpleData和sendComplexData，用于发送简朴和复杂数据。数据通过MethodChannel的invokeMethod函数发送到原生端，同时可以从原生端接收响应。

Android端（Kotlin）

在Android端，我们监听MethodChannel，并利用Gson库来解析JSON格式的复杂数据。

1. // MainActivity.kt
2. import android.os.Bundle
3. import androidx.appcompat.app.AppCompatActivity
4. import io.flutter.embedding.android.FlutterActivity
5. import io.flutter.embedding.engine.FlutterEngine
6. import io.flutter.plugin.common.MethodChannel
7. import com.google.gson.Gson
8. import com.google.gson.reflect.TypeToken
10. class MainActivity: FlutterActivity() {
11.     private val CHANNEL = "com.example.channel/transfer"
13.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
14.         super.configureFlutterEngine(flutterEngine)
16.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
17.             when (call.method) {
18.                 "sendSimpleData" -> {
19.                     val message = call.argument<String>("message")
20.                     // 使用传递的简单数据
21.                     // ...
23.                     // 发送响应回Flutter端
24.                     result.success("Received simple data: $message")
25.                 }
26.                 "sendComplexData" -> {
27.                     val data = call.argument<String>("data")
28.                     val type = object : TypeToken<Map<String, Any>>() {}.type
29.                     val complexData: Map<String, Any> = Gson().fromJson(data, type)
30.                     // 使用传递的复杂数据
31.                     // ...
33.                     // 发送响应回Flutter端
34.                     result.success("Received complex data")
35.                 }
36.                 else -> result.notImplemented()
37.             }
38.         }
39.     }
40. }

复制代码

iOS端（Swift）

在iOS端，我们监听MethodChannel，并利用Swift的Codable协议或JSONSerialization来解析JSON格式的复杂数据。

1. // AppDelegate.swift
2. import UIKit
3. import Flutter
5. @UIApplicationMain
6. @objc class AppDelegate: FlutterAppDelegate {
7.   private let channelName = "com.example.channel/transfer"
9.   override func application(
10.     _ application: UIApplication,
11.     didFinishLaunchingWithOptions launchOptions:[UIApplication.LaunchOptionsKey: Any]?
12.   ) -> Bool {
13.     GeneratedPluginRegistrant.register(with: self)
14.     guard let controller = window?.rootViewController as? FlutterViewController else {
15.       fatalError("rootViewController is not type FlutterViewController")
16.     }
17.     let channel = FlutterMethodChannel(name: channelName,
18.                                       binaryMessenger: controller.binaryMessenger)
19.     channel.setMethodCallHandler { [weak self] (call, result) in
20.       switch call.method {
21.       case "sendSimpleData":
22.         if let message = call.arguments as? String {
23.           // 使用传递的简单数据
24.           // ...
25.          
26.           // 发送响应回Flutter端
27.           result("Received simple data: \(message)")
28.         } else {
29.           result(FlutterError(code: "INVALID_ARGUMENT", message: "Expected a string argument", details: nil))
30.         }
31.       case "sendComplexData":
32.         if let jsonString = call.arguments as? String,
33.           let data = jsonString.data(using: .utf8) {
34.           do {
35.             // 使用Codable进行解析
36.             let user = try JSONDecoder().decode(User.self, from: data)
37.             // 使用传递的复杂数据
38.             // ...
39.             
40.             // 发送响应回Flutter端
41.             result("Received complex data")
42.           } catch {
43.             result(FlutterError(code: "JSON_PARSE_ERROR", message: "Error parsing JSON", details: nil))
44.           }
45.         } else {
46.           result(FlutterError(code: "INVALID_ARGUMENT", message: "Expected a JSON string argument", details: nil))
47.         }
48.       default:
49.         result(FlutterMethodNotImplemented)
50.       }
51.     }
52.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
53.   }
54. }
56. // 定义User结构体以匹配传递的复杂数据结构
57. struct User: Codable {
58.   var id: Int
59.   var name: String
60.   var email: String
61. }

复制代码

六、从原生页面回传数据到 Flutter

当必要从原生页面回传数据到Flutter时，有两种常见的方法：利用MethodChannel或者利用ActivityResult（Android端）/利用委托(delegate)/闭包(closures)（iOS端）。

• 利用MethodChannel回传数据：此方法实用于任何时候原生代码必要自动发送数据到Flutter端的环境，不仅限于页面返回时。Flutter端通过MethodChannel与原生代码通讯，可以接收来自原生端的数据。
  
• 利用ActivityResult（Android）/闭包和协议委托（iOS）：此方法一样平常用于原生页面关闭时，将数据回传到Flutter端。在Android上，可以通过setResult方法和Intent返回数据给前一个Activity。在iOS上，可以通过署理模式或闭包将数据回传给之前的控制器。
  

在Flutter端，我们必要设置好MethodChannel监听原生端发来的数据，或者在启动原生页面时等待结果。

方式一：远程过程调用

Flutter端设置了MethodChannel监听并处理惩罚原生端的调用，当原生代码处理惩罚完毕后，通过相同的MethodChannel返回结果。这是一种典范的RPC（远程过程调用）模式。

• 单次哀求-响应模式：Flutter发起调用，原生端返回数据，通讯完成。
  
• Flutter端自动哀求：Flutter通过invokeMethod自动哀求原生数据。
  
• 异步等待原生端响应：Flutter调用后利用await关键字等待原生端完成操作并返回结果。
  
• 实用场景：当Flutter必要原生端某个特定操作的结果时利用，比如获取设备信息、处理惩罚完毕的数据等。
  

Flutter端接收返回数据

1. import 'package:flutter/material.dart';
2. import 'package:flutter/services.dart';
4. class HomeScreen extends StatefulWidget {
5.   @override
6.   _HomeScreenState createState() => _HomeScreenState();
7. }
9. class _HomeScreenState extends State<HomeScreen> {
10.   // 创建一个MethodChannel，用于与原生平台通信
11.   static const platformChannel = MethodChannel('com.example.channel/transfer');
13.   // 用于显示从原生平台接收到的数据
14.   String _dataFromNative = 'No data';
16.   @override
17.   void initState() {
18.     super.initState();
19.     // 在 initState 中设置监听器以处理原生平台发来的方法调用
20.     platformChannel.setMethodCallHandler(_handleMethodCall);
21.   }
23.   // 处理从原生平台接收到的方法调用
24.   Future<dynamic> _handleMethodCall(MethodCall call) async {
25.     switch (call.method) {
26.       case 'onDataReturn':
27.         // 当原生平台返回数据时，更新状态以显示数据
28.         setState(() {
29.           _dataFromNative = call.arguments;
30.         });
31.         break;
32.       default:
33.         throw MissingPluginException('notImplemented');
34.     }
35.   }
37.   @override
38.   Widget build(BuildContext context) {
39.     return Scaffold(
40.       appBar: AppBar(
41.         title: Text('Flutter Native Data Return'),
42.       ),
43.       body: Center(
44.         // 显示从原生端接收到的数据
45.         child: Text(_dataFromNative),
46.       ),
47.     );
48.   }
49. }

复制代码

Android端（Kotlin）设置返回数据

在Android端，你可以在MainActivity中创建一个按钮，并在点击变乱中利用MethodChannel向Flutter发送消息：

1. // ...其他导入
2. import io.flutter.embedding.android.FlutterActivity
3. import io.flutter.plugin.common.MethodChannel
5. class MainActivity: FlutterActivity() {
6.     // 与Flutter端相同的通道名称
7.     private val CHANNEL = "com.example.channel/transfer"
9.     override fun onCreate(savedInstanceState: Bundle?) {
10.         super.onCreate(savedInstanceState)
12.         // 初始化MethodChannel
13.         val channel = MethodChannel(flutterEngine!!.dartExecutor.binaryMessenger, CHANNEL)
15.         // ...其他代码
17.         // 用于向Flutter发送数据
18.         fun sendDataToFlutter() {
19.             // 使用MethodChannel调用Flutter端定义的方法，并传递数据
20.             channel.invokeMethod("onDataReturn", "这是来自原生平台的数据")
21.         }
23.         // 假设有个触发发送数据到Flutter的逻辑
24.         sendDataToFlutter()
25.     }
26. }

复制代码

iOS端（Swift）设置返回数据

在iOS端，你可以在ViewController中为一个按钮，并在这个按钮回调中利用MethodChannel向Flutter发送消息：

1. // ...其他导入
2. import Flutter
4. class ViewController: UIViewController {
5.     private var channel: FlutterMethodChannel?
7.     override func viewDidLoad() {
8.         super.viewDidLoad()
10.         // 初始化MethodChannel
11.         guard let controller = self as? FlutterViewController else {
12.             fatalError("ViewController is not type FlutterViewController")
13.         }
14.         channel = FlutterMethodChannel(name: "com.example.channel/transfer", binaryMessenger: controller.binaryMessenger)
16.         // ...其他代码
18.         // 用于向Flutter发送数据
19.         func sendDataToFlutter() {
20.             // 使用MethodChannel调用Flutter端定义的方法，并传递数据
21.             channel?.invokeMethod("onDataReturn", arguments: "这是来自原生平台的数据")
22.         }
24.         // 假设有个触发发送数据到Flutter的逻辑
25.         sendDataToFlutter()
26.     }
27. }

复制代码

方式二：变乱订阅模式

是一种变乱订阅模式，Flutter端通过MethodChannel设置监听器，任何时候原生端都可以自动调用这个通道并发送数据到Flutter，而Flutter端则在_listener_方法中处理惩罚全部接收到的消息。

• 持续监听模式：Flutter监听原生端的方法调用，原生端可以在任何时刻自动发送消息。
  
• 原生端自动发送消息：原生代码在适当的时候（如某变乱发生后）自动调用MethodChannel向Flutter发送消息。
  
• 实用场景：对于原生端变乱的及时监听和处理惩罚，如位置更新、传感器数据等。
  

Flutter端接收返回数据

1. import 'package:flutter/material.dart';
2. import 'package:flutter/services.dart';
4. class HomeScreen extends StatelessWidget {
5.   // 创建MethodChannel实例
6.   static const platformChannel = MethodChannel('com.example.channel/transfer');
8.   // 调用原生页面并等待返回结果
9.   Future<void> _navigateAndDisplaySelection(BuildContext context) async {
10.     final result = await platformChannel.invokeMethod('startNativeView');
11.     // 使用返回结果更新UI或状态
12.     if (result != null) {
13.       ScaffoldMessenger.of(context).showSnackBar(
14.         SnackBar(content: Text('原生页面返回的数据: $result')),
15.       );
16.     }
17.   }
19.   @override
20.   Widget build(BuildContext context) {
21.     return Scaffold(
22.       appBar: AppBar(
23.         title: Text('Flutter Native Data Return'),
24.       ),
25.       body: Center(
26.         child: ElevatedButton(
27.           onPressed: () => _navigateAndDisplaySelection(context),
28.           child: Text('打开原生页面'),
29.         ),
30.       ),
31.     );
32.   }
33. }

复制代码

在上面的Flutter端代码中，我们通过platformChannel.invokeMethod调用原生端的方法打开一个原生页面，并利用await关键字等待异步结果。当原生页面关闭并返回数据时，我们可以通过result变量接收这个数据，并通过ScaffoldMessenger显示在一个SnackBar中。

Android端（Kotlin）设置返回数据

在Android端，我们可以利用setResult方法和Intent回传数据。

1. // 原生页面Activity
2. import android.app.Activity
3. import android.content.Intent
4. import android.os.Bundle
6. class NativeActivity : Activity() {
7.     override fun onCreate(savedInstanceState: Bundle?) {
8.         super.onCreate(savedInstanceState)
9.         // 设置布局、初始化等操作
10.         // ...
12.         // 假设这是一个按钮点击后触发的事件
13.         val button = findViewById<Button>(R.id.button_id)
14.         button.setOnClickListener {
15.             val returnIntent = Intent()
16.             returnIntent.putExtra("result_key", "这里是从原生返回的数据")
17.             setResult(Activity.RESULT_OK, returnIntent)
18.             finish() // 关闭当前原生页面，回传数据到Flutter
19.         }
20.     }
21. }

复制代码

 在Android原生端，你必要定义一个MethodChannel并监听startNativeView方法调用，然后打开一个新的Activity，并在关闭时设置返回结果：

1. // MainActivity.kt (Android端)
2. import io.flutter.embedding.android.FlutterActivity
3. import io.flutter.embedding.engine.FlutterEngine
4. import io.flutter.plugin.common.MethodChannel
6. class MainActivity: FlutterActivity() {
7.     private val CHANNEL = "com.example.channel/transfer"
9.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
10.         super.configureFlutterEngine(flutterEngine)
11.         
12.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler {
13.             call, result ->
14.             if (call.method == "startNativeView") {
15.                 // 调用原生页面
16.                 val intent = Intent(this, NativeActivity::class.java)
17.                 startActivityForResult(intent, REQUEST_CODE)
18.             } else {
19.                 result.notImplemented()
20.             }
21.         }
22.     }
24.     // 接收原生页面返回的结果
25.     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
26.         super.onActivityResult(requestCode, resultCode, data)
28.         if (requestCode == REQUEST_CODE && resultCode == Activity.RESULT_OK) {
29.             val returnData = data?.getStringExtra("result_key") ?: "No data"
30.             // 使用MethodChannel返回数据到Flutter
31.             MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).invokeMethod("onDataReturn", returnData)
32.         }
33.     }
35.     companion object {
36.         const val REQUEST_CODE = 100
37.     }
38. }

复制代码

iOS端（Swift）设置返回数据

在iOS端，我们可以利用闭包或者协议委托往返传数据。

1. // 原生页面ViewController
2. import UIKit
4. class NativeViewController: UIViewController {
5.     // 定义闭包，用于回传数据
6.     var onReturnData: ((String) -> Void)?
8.     override func viewDidLoad() {
9.         super.viewDidLoad()
10.         // 设置布局、初始化等操作
11.         // ...
13.         let button = UIButton()
14.         button.addTarget(self, action: #selector(didTapButton), for: .touchUpInside)
15.     }
17.     @objc func didTapButton() {
18.         // 当按钮被点击时，通过闭包传递数据回Flutter端
19.         onReturnData?("这里是从原生返回的数据")
20.         dismiss(animated: true, completion: nil) // 关闭当前页面
21.     }
22. }

复制代码

在iOS原生端，你必要在Flutter与原生端之间创建一个MethodChannel，并监听Flutter端的调用，然后打开一个新的ViewController，并在关闭时回传数据：

1. // AppDelegate.swift (iOS端)
2. import UIKit
3. import Flutter
5. @UIApplicationMain
6. @objc class AppDelegate: FlutterAppDelegate {
7.   private var flutterResult: FlutterResult?
9.   override func application(
10.     _ application: UIApplication,
11.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
12.   ) -> Bool {
13.     if let controller = window?.rootViewController as? FlutterViewController {
14.       let channel = FlutterMethodChannel(name: "com.example.channel/transfer",
15.                                         binaryMessenger: controller.binaryMessenger)
17.       channel.setMethodCallHandler({
18.         [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
19.         // 保存FlutterResult回调
20.         self?.flutterResult = result
21.         // 检查是否是打开原生页面的调用
22.         if call.method == "startNativeView" {
23.           self?.showNativeView(from: controller)
24.         } else {
25.           result(FlutterMethodNotImplemented)
26.         }
27.       })
28.     }
29.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
30.   }
32.   private func showNativeView(from controller: FlutterViewController) {
33.     let nativeViewController = NativeViewController()
34.     // 设置回调闭包，以便在ViewController关闭时返回数据
35.     nativeViewController.onReturnData = { [weak self] data in
36.       self?.flutterResult?(data)
37.     }
38.     // 展示原生ViewController
39.     controller.present(nativeViewController, animated: true, completion: nil)
40.   }
41. }

复制代码

七、错误处理惩罚和异常安全

错误处理惩罚是编写健壮软件的重要组成部分。下面将详细先容怎样在Flutter、Android（Kotlin）、iOS（Swift）三个平台上举行错误处理惩罚和异常安全。
我们在Flutter端通过MethodChannel调用原生代码，并且在原生端利用try-catch（Kotlin）或do-try-catch（Swift）来捕捉大概发生的异常。假如捕捉到异常，原生端会通过MethodChannel.Result（Kotlin）或FlutterResult（Swift）将错误信息通报回Flutter。
异常处理惩罚机制确保了当原生代码执行出错时，Flutter端可以收到错误信息，并且可以根据错误信息做出相应的处理惩罚，从而提供更加健壮的用户体验。

Flutter端处理惩罚原生代码抛出的异常

在Flutter端，我们可以通过try-catch块来捕捉和处理惩罚通过MethodChannel调用原生代码时大概抛出的异常。

1. import 'package:flutter/material.dart';
2. import 'package:flutter/services.dart';
4. class ExceptionHandlingScreen extends StatefulWidget {
5.   @override
6.   _ExceptionHandlingScreenState createState() => _ExceptionHandlingScreenState();
7. }
9. class _ExceptionHandlingScreenState extends State<ExceptionHandlingScreen> {
10.   static const platformChannel = MethodChannel('com.example.channel/methods');
12.   String _result = 'No data';
14.   Future<void> _invokeNativeMethod(String methodName) async {
15.     try {
16.       final String result = await platformChannel.invokeMethod(methodName);
17.       setState(() {
18.         _result = result;
19.       });
20.     } on PlatformException catch (e) {
21.       // 捕获由原生代码抛出的异常
22.       setState(() {
23.         _result = "原生代码发生异常：${e.message}";
24.       });
25.     } catch (e) {
26.       // 捕获其他异常
27.       setState(() {
28.         _result = "未知异常：${e.toString()}";
29.       });
30.     }
31.   }
33.   @override
34.   Widget build(BuildContext context) {
35.     return Scaffold(
36.       appBar: AppBar(
37.         title: Text('异常处理示例'),
38.       ),
39.       body: Center(
40.         child: Column(
41.           mainAxisAlignment: MainAxisAlignment.center,
42.           children: <Widget>[
43.             ElevatedButton(
44.               onPressed: () => _invokeNativeMethod('someMethod'),
45.               child: Text('调用原生方法'),
46.             ),
47.             Padding(
48.               padding: const EdgeInsets.all(8.0),
49.               child: Text(_result),
50.             ),
51.           ],
52.         ),
53.       ),
54.     );
55.   }
56. }

复制代码

Android端（Kotlin）

在Android（Kotlin）端，我们可以利用try-catch块来处理惩罚大概在执行方法调用时发生的异常，并通过MethodChannel.Result向Flutter端通报错误信息。

1. // MainActivity.kt (Android端)
2. import io.flutter.embedding.android.FlutterActivity
3. import io.flutter.embedding.engine.FlutterEngine
4. import io.flutter.plugin.common.MethodChannel
6. class MainActivity : FlutterActivity() {
7.     private val CHANNEL = "com.example.channel/methods"
9.     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
10.         super.configureFlutterEngine(flutterEngine)
12.         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
13.             try {
14.                 when (call.method) {
15.                     "someMethod" -> {
16.                         // 你的原生方法处理
17.                         result.success("从原生返回的数据")
18.                     }
19.                     else -> result.notImplemented()
20.                 }
21.             } catch (e: Exception) {
22.                 // 捕获异常并将错误返回到Flutter
23.                 result.error("ERROR", "方法执行出错: ${e.localizedMessage}", null)
24.             }
25.         }
26.     }
27. }

复制代码

iOS端（Swift）

在iOS（Swift）端，我们一样平常通过do-try-catch块来处理惩罚方法调用时大概抛出的异常，并通过FlutterResult通报错误信息给Flutter端。

1. // AppDelegate.swift (iOS端)
2. import UIKit
3. import Flutter
5. @UIApplicationMain
6. @objc class AppDelegate: FlutterAppDelegate {
7.   private let channelName = "com.example.channel/methods"
9.   override func application(
10.     _ application: UIApplication,
11.     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
12.   ) -> Bool {
13.     guard let controller = window?.rootViewController as? FlutterViewController else {
14.       fatalError("rootViewController is not type FlutterViewController")
15.     }
16.     let channel = FlutterMethodChannel(name: channelName, binaryMessenger: controller.binaryMessenger)
18.     channel.setMethodCallHandler { (call, result) in
19.       // 检查方法名称并执行相应的原生代码
20.       if call.method == "someMethod" {
21.         do {
22.           // 尝试执行方法并捕获可能的异常
23.           let data = try self.someNativeMethod()
24.           result(data)
25.         } catch {
26.           // 如果有异常，将异常信息返回给Flutter
27.           result(FlutterError(code: "ERROR",
28.                               message: "方法执行出错: \(error.localizedDescription)",
29.                               details: nil))
30.         }
31.       } else {
32.         result(FlutterMethodNotImplemented)
33.       }
34.     }
36.     return super.application(application, didFinishLaunchingWithOptions: launchOptions)
37.   }
39.   private func someNativeMethod() throws -> String {
40.     // 这里是你的原生方法实现，可能会抛出异常
41.     // 例如，我们这里直接抛出一个异常来模拟错误情况
42.     throw NSError(domain: "", code: 0, userInfo: [NSLocalizedDescriptionKey: "演示错误"])
43.   }
44. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。