Flutter 学习之旅之 Flutter 和 Android 原生实现数据交互的MethodChanel和EventChannel方式的简单整理

[Flutter 学习之旅之 Flutter 和 Android 原生实现数据交互的MethodChanel和EventChannel方式的简单整理](#Flutter 学习之旅之 Flutter 和 Android 原生实现数据交互的MethodChanel和EventChannel方式的简单整理)

一、简单介绍

[二、Flutter 和 Android 原生之间的数据交互](#二、Flutter 和 Android 原生之间的数据交互)

1、MethodChannel

2、EventChannel

[3、MethodChannel 与 EventChannel 的主要区别](#3、MethodChannel 与 EventChannel 的主要区别)

三、简单的效果预览

四、案例基础环境配置

[五、使用 MethodChanel 实现交互](#五、使用 MethodChanel 实现交互)

[六、使用 MethodChanel 实现交互](#六、使用 MethodChanel 实现交互)

一、简单介绍

Flutter 是一款开源的 UI 软件开发工具包，由 Google 开发和维护。它允许开发者使用一套代码同时构建跨平台的应用程序，包括移动设备（iOS 和 Android）、Web 和桌面平台（Windows、macOS 和 Linux）。

Flutter 使用 Dart 编程语言，它可以将代码编译为 ARM 或 Intel 机器代码以及 JavaScript，从而实现快速的性能。Flutter 提供了一个丰富的预置小部件库，开发者可以根据自己的需求灵活地控制每个像素，从而创建自定义的、适应性强的设计，这些设计在任何屏幕上都能呈现出色的外观和感觉。

二、Flutter 和 Android 原生之间的数据交互

Flutter 和 Android 原生之间的数据交互主要通过平台通道（Platform Channels）实现，包括 MethodChannel 和 EventChannel。

1、MethodChannel

定义： MethodChannel 是 Flutter 与原生平台之间进行通信的一种方式，允许 Dart 代码调用原生代码中的方法，并接收返回结果。它支持双向通信，即 Dart 可以调用原生方法，原生也可以调用 Dart 方法。

特点：

单次调用：主要用于一次性请求和响应，适合执行特定的操作并获取结果。

简单高效：适合简单的数据交互，开销较低。

异步通信：调用原生方法后，Dart 代码会等待原生代码处理完成并返回结果。

使用场景：

调用原生平台的特定功能，如获取设备信息、访问传感器等。

执行一次性任务，如打开相机、保存文件等。

2、EventChannel

定义： EventChannel 是用于接收原生平台发送的连续事件流的通道。它允许原生代码向 Dart 代码发送一系列数据或事件，适合实时数据更新。

特点：

持续数据流：适合处理连续的事件或数据流，如传感器数据、网络状态更新等。

双向通信：虽然主要用于原生向 Dart 发送数据，但也支持 Dart 向原生发送请求。

异步通信：数据流是异步发送的，Dart 代码通过监听事件流来接收数据。

使用场景：

监听传感器数据（如加速度计、陀螺仪）。

监听网络状态变化、实时消息推送等。

3、MethodChannel 与 EventChannel 的主要区别

|----------|-------------------|-------------------|
| 特点 | MethodChannel | EventChannel |
| 通信模式 | 单次调用，请求-响应模式 | 持续数据流，事件监听模式 |
| 适用场景 | 适合一次性操作，如调用原生方法 | 适合实时数据流，如传感器数据 |
| 通信方向 | 主要用于 Dart 调用原生方法 | 主要用于原生向 Dart 发送事件 |
| 性能开销 | 较低，适合简单数据交互 | 较高，适合实时数据更新 |

总结

MethodChannel 是用于单次调用原生方法的通道，适合执行特定操作并获取结果。

EventChannel 是用于接收原生平台发送的连续事件流的通道，适合实时数据更新。
选择哪种通道取决于具体需求：如果需要执行一次性任务，使用 MethodChannel；如果需要实时接收数据流，使用 EventChannel。

三、简单的效果预览

MethodChanel：

EventChanel:

四、案例基础环境配置

1、在 Android Studio 中创建一个 Flutter 工程

2、选择创建一个 Flutter Module

3、再创建一个 Android 工程

4、回到 Flutter 工程，进行 Flutter - Build AAR 编译

5、编译完成后，会有提示如何在 Android 工程中引用

6、在 Android 工程中，根据提示，在 settings.gradle 和 build.gradle 添加如下的提示内容

7、在 AndroidManifest.xml 中，添加 FlutterActivity 相关属性

五、使用 MethodChanel 实现交互

1、Flutter 端代码

Dart 复制代码

import 'package:flutter/material.dart';
import 'package:flutter/services.dart'; // 导入用于与原生平台交互的包

void main() {
  runApp(MyApp()); // 启动应用
}

// 定义一个无状态的 MyApp 组件，作为应用的根组件
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold( // 使用 Scaffold 提供基本的布局结构
        appBar: AppBar(title: Text('Flutter Native Interaction')), // 设置应用栏标题
        body: Center(child: NativeStringWidget()), // 在中心放置 NativeStringWidget 组件
      ),
    );
  }
}

// 定义一个有状态的 NativeStringWidget 组件，用于与原生平台交互
class NativeStringWidget extends StatefulWidget {
  @override
  _NativeStringWidgetState createState() => _NativeStringWidgetState();
}

// 定义 NativeStringWidget 的状态类
class _NativeStringWidgetState extends State<NativeStringWidget> {
  String _nativeString = 'Press button to get native string'; // 初始化显示的字符串
  String _result = ' native call flutter string'; // 初始化另一个显示的字符串

  // 定义一个异步方法，用于调用原生平台的方法
  Future<void> _getNativeString() async {
    try {
      // 通过 MethodChannel 调用原生平台的 'getNativeString' 方法
      final String result = await MethodChannel('com.example/native')
          .invokeMethod('getNativeString');
      setState(() {
        _nativeString = result; // 更新显示的字符串为原生方法返回的结果
      });
    } catch (e) {
      setState(() {
        // 如果调用失败，更新显示的字符串为错误信息
        _nativeString = 'Failed to get native string: $e';
      });
    }
  }

  // 定义另一个异步方法，用于调用原生平台的 'jumpToNative' 方法
  Future<void> _incrementCounter() async {
    Map<String, dynamic> result = {'message': '我从Flutter页面回来了'}; // 准备传递给原生平台的参数
    try {
      // 调用原生平台的 'jumpToNative' 方法，并传递参数
      _result = await MethodChannel('com.example/native').invokeMethod('jumpToNative', result);
    } on PlatformException catch (e) {
      // 如果调用失败，捕获 PlatformException 并更新显示的字符串为错误信息
      _result = "Failed: '${e.message}'.";
    }
    setState(() {}); // 触发界面更新
  }

  @override
  void initState() {
    _incrementCounter(); // 在组件初始化时调用 _incrementCounter 方法
    super.initState(); // 调用父类的初始化方法
  }

  @override
  Widget build(BuildContext context) {
    return Column( // 使用 Column 布局，垂直排列子组件
      mainAxisAlignment: MainAxisAlignment.center, // 将子组件居中对齐
      children: <Widget>[
        Text(_nativeString), // 显示从原生平台获取的字符串

        SizedBox(height: 20), // 添加一个高度为 20 的间隔
        ElevatedButton( // 定义一个按钮
          onPressed: _getNativeString, // 点击按钮时调用 _getNativeString 方法
          child: Text('Get Native String'), // 按钮上的文本
        ),
        Text(_result), // 显示另一个字符串
      ],
    );
  }
}

代码功能说明

MyApp：

定义了应用的根组件，使用 MaterialApp 和 Scaffold 提供基本的布局结构。

在 Scaffold 的 body 中放置了 NativeStringWidget 组件。

NativeStringWidget：

定义了一个有状态的组件，用于与原生平台交互。

包含两个状态变量 _nativeString 和 _result，分别用于显示从原生平台获取的字符串和调用结果。

_getNativeString 方法：

通过 MethodChannel 调用原生平台的 getNativeString 方法。

如果调用成功，更新 _nativeString 为返回的结果；如果失败，显示错误信息。

_incrementCounter 方法：

通过 MethodChannel 调用原生平台的 jumpToNative 方法，并传递一个包含消息的 Map。

如果调用成功，更新 _result 为返回的结果；如果失败，捕获异常并显示错误信息。

initState 方法：

在组件初始化时调用 _incrementCounter 方法，执行与原生平台的交互。

build 方法：

使用 Column 布局，垂直排列了两个文本组件和一个按钮。

按钮点击时调用 _getNativeString 方法，从原生平台获取字符串并更新界面。

与原生平台的交互

在 Dart 端，通过 MethodChannel 调用原生平台的方法。

在原生平台（如 Android 或 iOS），需要定义对应的 MethodChannel，并实现相应的逻辑来处理 Dart 端的调用请求。

原生平台可以通过 MethodChannel 返回结果，Dart 端通过 await 接收并处理返回值。

2、Android 端的代码

java 复制代码

package com.example.test_android_embedding_flutter_0428;

import android.widget.Toast;

import io.flutter.embedding.android.FlutterActivity; // 导入 FlutterActivity，用于嵌入 Flutter
import io.flutter.embedding.engine.FlutterEngine; // 导入 FlutterEngine，用于管理 Flutter 的运行
import io.flutter.plugin.common.MethodChannel; // 导入 MethodChannel，用于与 Flutter 的方法调用交互

// 定义 MainActivity，继承自 FlutterActivity
public class MainActivity extends FlutterActivity {
    private static final String CHANNEL = "com.example/native"; // 定义一个常量字符串，作为 MethodChannel 的名称

    // 重写 configureFlutterEngine 方法，用于配置 FlutterEngine
    @Override
    public void configureFlutterEngine(FlutterEngine flutterEngine) {
        super.configureFlutterEngine(flutterEngine); // 调用父类的 configureFlutterEngine 方法

        // 创建一个 MethodChannel 实例
        new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
                .setMethodCallHandler((call, result) -> { // 设置方法调用处理器
                    // 判断调用的方法名
                    if (call.method.equals("getNativeString")) {
                        // 如果方法名为 "getNativeString"，返回一个字符串给 Flutter
                        result.success("Hello from Android Native!");
                    } else if (call.method.equals("jumpToNative")) {
                        // 如果方法名为 "jumpToNative"，处理传递的参数
                        if (call.arguments != null) {
                            // 如果有参数传递，显示一个 Toast
                            Toast.makeText(this, call.argument("message"), Toast.LENGTH_SHORT).show();
                        } else {
                            // 如果没有参数传递，显示一个提示 Toast
                            Toast.makeText(this, "回调参数为空", Toast.LENGTH_SHORT).show();
                        }
                        // 返回一个成功消息给 Flutter
                        result.success("Activity -> Flutter 接收回调的返回值成功");
                    } else {
                        // 如果调用的方法名不匹配，返回未实现的错误
                        result.notImplemented();
                    }
                });
    }
}

代码功能说明

MainActivity：

继承自 FlutterActivity，这是 Flutter 提供的一个用于嵌入 Flutter 内容的 Android 活动类。

重写了 configureFlutterEngine 方法，用于配置 Flutter 的运行环境。

CHANNEL：

定义了一个常量字符串 "com.example/native"，用于标识与 Flutter 交互的 MethodChannel。

这个字符串必须与 Flutter 端的 MethodChannel 名称一致。

configureFlutterEngine 方法：

在这个方法中，创建了一个 MethodChannel 实例，用于处理来自 Flutter 的方法调用。

flutterEngine.getDartExecutor().getBinaryMessenger() 是 Flutter 提供的用于与 Dart 交互的消息传递器。

setMethodCallHandler：

设置了一个方法调用处理器，用于处理 Flutter 端调用的方法。

处理器接收两个参数：

call：包含调用的方法名和参数。

result：用于返回调用结果。

方法处理逻辑：

getNativeString：

如果 Flutter 调用的方法名是 "getNativeString"，返回一个字符串 "Hello from Android Native!" 给 Flutter。

jumpToNative：

如果 Flutter 调用的方法名是 "jumpToNative"，检查是否有参数传递。

如果有参数，提取参数中的 "message" 并显示一个 Toast。

如果没有参数，显示一个提示 Toast。

最后返回一个成功消息 "Activity -> Flutter 接收回调的返回值成功" 给 Flutter。

其他方法：

如果调用的方法名不匹配，返回 notImplemented，表示该方法未实现。

与 Flutter 的交互

在 Android 端，通过 MethodChannel 接收 Flutter 的方法调用。

根据方法名处理逻辑，返回结果给 Flutter。

如果需要向 Flutter 传递数据，可以通过 result.success() 方法返回成功结果，或者通过 result.error() 方法返回错误信息。

六、使用 MethodChanel 实现交互

1、Flutter 端代码

Dart 复制代码

import 'package:flutter/material.dart'; // 导入 Flutter 的 Material Design 组件库
import 'package:flutter/services.dart'; // 导入用于与原生平台交互的包

void main() {
  runApp(MyApp()); // 启动应用，运行 MyApp 组件
}

// 定义一个无状态的 MyApp 组件，作为应用的根组件
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp( // 使用 MaterialApp 提供基本的 Material Design 风格
      home: Scaffold( // 使用 Scaffold 提供基本的布局结构
        appBar: AppBar( // 设置应用栏（AppBar）
          title: Text('Flutter Native Interaction'), // 应用栏标题
        ),
        body: Center( // 将子组件居中对齐
          child: NativeEventsWidget(), // 在中心放置 NativeEventsWidget 组件
        ),
      ),
    );
  }
}

// 定义一个有状态的 NativeEventsWidget 组件，用于接收原生平台发送的事件
class NativeEventsWidget extends StatefulWidget {
  @override
  _NativeEventsWidgetState createState() => _NativeEventsWidgetState();
}

// 定义 NativeEventsWidget 的状态类
class _NativeEventsWidgetState extends State<NativeEventsWidget> {
  late Stream<String> _nativeEvents; // 声明一个 Stream 对象，用于接收原生平台的事件流

  @override
  void initState() {
    super.initState(); // 调用父类的初始化方法
    // 初始化 EventChannel，用于接收原生平台发送的事件流
    _nativeEvents = EventChannel('com.example/native_events')
        .receiveBroadcastStream() // 接收广播事件流
        .map((event) => event.toString()); // 将事件数据转换为字符串
  }

  @override
  Widget build(BuildContext context) {
    return StreamBuilder<String>( // 使用 StreamBuilder 构建 UI，监听事件流
      stream: _nativeEvents, // 监听的事件流
      builder: (context, snapshot) { // 构建器，根据事件流的状态构建 UI
        if (snapshot.hasError) { // 如果发生错误
          return Text('Error: ${snapshot.error}'); // 显示错误信息
        } else if (snapshot.hasData) { // 如果有数据
          return Text('Native Event: ${snapshot.data}'); // 显示接收到的事件数据
        } else { // 如果没有数据
          return CircularProgressIndicator(); // 显示一个加载指示器
        }
      },
    );
  }
}

代码功能说明

MyApp：

定义了应用的根组件，使用 MaterialApp 和 Scaffold 提供基本的布局结构。

在 Scaffold 的 body 中放置了 NativeEventsWidget 组件。

NativeEventsWidget：

定义了一个有状态的组件，用于接收原生平台发送的事件流。

在 initState 方法中初始化了一个 EventChannel，用于接收原生平台的事件流。

EventChannel：

通过 EventChannel 的 receiveBroadcastStream 方法接收原生平台发送的事件流。

使用 map 方法将事件数据转换为字符串。

StreamBuilder：

使用 StreamBuilder 构建 UI，监听事件流的状态。

根据事件流的状态（是否有数据、是否发生错误）动态更新 UI：

如果发生错误，显示错误信息。

如果有数据，显示接收到的事件数据。

如果没有数据，显示一个加载指示器。

与原生平台的交互

在 Dart 端，通过 EventChannel 接收原生平台发送的事件流。

原生平台需要通过 EventChannel 发送事件流，Flutter 端通过 StreamBuilder 监听这些事件并更新 UI。

注意事项

确保原生平台（如 Android 或 iOS）已经正确配置了 EventChannel，并能够发送事件流。

EventChannel 的名称（如 'com.example/native_events'）必须与原生平台的配置一致。

2、Android 端的代码

java 复制代码

package com.example.test_android_embedding_flutter_0428;

import android.os.Bundle; // 导入用于处理 Android 活动生命周期的 Bundle
import android.os.Handler; // 导入 Handler，用于在主线程上执行任务
import android.os.Looper; // 导入 Looper，用于获取主线程的 Looper 实例
import android.widget.Toast; // 导入 Toast，用于显示提示信息

import io.flutter.embedding.android.FlutterActivity; // 导入 FlutterActivity，用于嵌入 Flutter
import io.flutter.embedding.engine.FlutterEngine; // 导入 FlutterEngine，用于管理 Flutter 的运行
import io.flutter.plugin.common.EventChannel; // 导入 EventChannel，用于与 Flutter 的事件流交互

// 定义 MainActivity，继承自 FlutterActivity
public class MainActivity extends FlutterActivity {
    private static final String EVENT_CHANNEL = "com.example/native_events"; // 定义 EventChannel 的名称

    @Override
    public void configureFlutterEngine(FlutterEngine flutterEngine) {
        super.configureFlutterEngine(flutterEngine); // 调用父类的 configureFlutterEngine 方法

        // 创建 EventChannel 并设置事件处理器
        new EventChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), EVENT_CHANNEL)
                .setStreamHandler(new EventChannel.StreamHandler() {
                    private Handler mainHandler = new Handler(Looper.getMainLooper()); // 获取主线程的 Handler

                    @Override
                    public void onListen(Object arguments, EventChannel.EventSink events) {
                        // 在子线程中模拟事件发送
                        new Thread(() -> {
                            for (int i = 0; i < 10; i++) { // 模拟发送 10 次事件
                                try {
                                    Thread.sleep(1000); // 每隔 1 秒发送一次事件
                                    final String event = "Event " + i + " from Android"; // 构造事件数据

                                    // 使用主线程的 Handler 来发送事件
                                    mainHandler.post(() -> {
                                        events.success(event); // 发送成功事件
                                    });
                                } catch (InterruptedException e) {
                                    // 如果线程被中断，发送错误事件
                                    mainHandler.post(() -> {
                                        events.error("ERROR", "Thread interrupted", null); // 发送错误事件
                                    });
                                }
                            }
                            // 发送结束事件
                            mainHandler.post(events::endOfStream); // 通知 Flutter 事件流已结束
                        }).start();
                    }

                    @Override
                    public void onCancel(Object arguments) {
                        // 取消事件监听时的处理逻辑
                        // 这里可以添加清理资源或停止事件发送的逻辑
                    }
                });
    }
}

代码功能说明

MainActivity：

继承自 FlutterActivity，这是 Flutter 提供的一个用于嵌入 Flutter 内容的 Android 活动类。

重写了 configureFlutterEngine 方法，用于配置 Flutter 的运行环境。

EVENT_CHANNEL：

定义了一个常量字符串 "com.example/native_events"，用于标识与 Flutter 交互的 EventChannel。

这个字符串必须与 Flutter 端的 EventChannel 名称一致。

configureFlutterEngine 方法：

在这个方法中，创建了一个 EventChannel 实例，用于处理来自 Flutter 的事件流请求。

flutterEngine.getDartExecutor().getBinaryMessenger() 是 Flutter 提供的用于与 Dart 交互的消息传递器。

setStreamHandler：

设置了一个事件流处理器，用于处理 Flutter 端的事件流请求。

处理器需要实现两个方法：

onListen：当 Flutter 端开始监听事件流时调用。

onCancel：当 Flutter 端取消监听事件流时调用。

onListen 方法：

在子线程中模拟事件发送：

使用 for 循环模拟发送 10 次事件。

每隔 1 秒发送一次事件，通过 Thread.sleep(1000) 实现延时。

构造事件数据 "Event " + i + " from Android"。

onCancel 方法：

当 Flutter 端取消监听事件流时调用。

这里可以添加清理资源或停止事件发送的逻辑（当前代码中未实现具体逻辑）。

与 Flutter 的交互

在 Android 端，通过 EventChannel 向 Flutter 发送事件流。

Flutter 端通过 StreamBuilder 监听这些事件并更新 UI。

确保 EventChannel 的名称（如 "com.example/native_events"）与 Flutter 端的配置一致。

通过上述代码和注释，你可以清楚地理解如何在 Android 端通过 EventChannel 向 Flutter 发送事件流，并确保所有与 UI 相关的操作都在主线程上执行。

七、其他代码

1、AndroidManifest.xml

XML 复制代码

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
 
    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Test_Android_Embedding_Flutter_0428"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
            android:hardwareAccelerated="true"
            android:windowSoftInputMode="adjustResize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

2、settings.gradle

html 复制代码

pluginManagement {
    // 配置插件管理相关的设置
    repositories {
        // 定义插件管理的仓库来源
        google {
            // 使用 Google 的 Maven 仓库
            content {
                // 定义需要包含的组（group）正则表达式
                includeGroupByRegex("com\\.android.*")  // 包含以 "com.android" 开头的组
                includeGroupByRegex("com\\.google.*")   // 包含以 "com.google" 开头的组
                includeGroupByRegex("androidx.*")       // 包含以 "androidx" 开头的组
            }
        }
        mavenCentral()  // 使用 Maven Central 仓库
        gradlePluginPortal()  // 使用 Gradle 插件门户
    }
}
 
dependencyResolutionManagement {
    // 配置依赖解析相关的设置
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)  // 设置仓库模式，如果项目中有仓库配置错误则失败
    repositories {
        google()  // 使用 Google 的 Maven 仓库
        mavenCentral()  // 使用 Maven Central 仓库
    }
 
    // 定义 Flutter 模块的存储 URL
    String storageUrl = System.env.FLUTTER_STORAGE_BASE_URL ?: "https://storage.googleapis.com"
    // 如果环境变量 FLUTTER_STORAGE_BASE_URL 未设置，则使用默认的 Flutter 存储 URL
    // 注意：该 URL 是 Flutter 依赖项的默认存储位置，但由于网络原因，可能无法直接访问
    // 如果您遇到问题，请检查链接的合法性或在网络正常的情况下重试
 
    repositories {
        maven {
            // 定义本地 Maven 仓库路径
            url 'D:/UsingForXAN/Projects/AndroidStudioProjects/FlutterProject/test_flutter_module_0418/build/host/outputs/repo'
        }
        maven {
            // 定义远程 Maven 仓库路径
            url "$storageUrl/download.flutter.io"
        }
    }
}
 
// 设置项目的根项目名称
rootProject.name = "Test_Android_Embedding_Flutter_0428"
// 包含子项目 'app'，这是 Android 项目的主模块
include ':app'

3、build.gradle

html 复制代码

plugins {
    alias(libs.plugins.android.application)
}
// 定义项目使用的插件
// 这里使用了 alias 来引用预定义的插件，通常是定义在 buildSrc 或其他地方的插件别名
// 这里引用的是 Android 应用插件，用于构建 Android 应用
 
android {
    namespace 'com.example.test_android_embedding_flutter_0428'
    // 设置项目的命名空间，用于区分不同的应用
    compileSdk 35
    // 设置编译 SDK 的版本，这里是 API 级别 35
 
    defaultConfig {
        applicationId "com.example.test_android_embedding_flutter_0428"
        // 设置应用的唯一标识符
        minSdk 28
        // 设置应用支持的最低 SDK 版本
        targetSdk 34
        // 设置应用的目标 SDK 版本
        versionCode 1
        // 设置应用的版本代码，用于内部版本管理
        versionName "1.0"
        // 设置应用的版本名称，显示给用户
 
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        // 设置用于运行 Android 测试的测试运行器
    }
 
    buildTypes {
        release {
            minifyEnabled false
            // 是否启用代码混淆，这里设置为 false 表示不启用
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
            // 指定 ProGuard 配置文件，用于代码混淆规则
        }
        profile {
            initWith debug
            // 将 profile 构建类型初始化为 debug 构建类型的配置
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        // 设置源代码的 Java 版本兼容性
        targetCompatibility JavaVersion.VERSION_1_8
        // 设置目标字节码的 Java 版本兼容性
    }
}
 
dependencies {
    // 定义项目的依赖项
 
    implementation libs.appcompat
    // 添加 AndroidX AppCompat 库的依赖，用于支持旧版本 Android 的兼容性
    implementation libs.material
    // 添加 Material Design 组件库的依赖，用于构建 Material Design 风格的界面
    implementation libs.activity
    // 添加 Activity 组件库的依赖，用于支持新的 Activity API
    implementation libs.constraintlayout
    // 添加 ConstraintLayout 布局库的依赖，用于构建复杂的布局
 
    testImplementation libs.junit
    // 添加 JUnit 测试框架的依赖，用于编写单元测试
    androidTestImplementation libs.ext.junit
    // 添加扩展的 JUnit 测试框架的依赖，用于 Android 测试
    androidTestImplementation libs.espresso.core
    // 添加 Espresso 测试框架的依赖，用于编写 UI 测试
 
    debugImplementation 'com.example.test_flutter_module_0418:flutter_debug:1.0'
    // 在 debug 构建类型中添加 Flutter 模块的 debug 版本依赖
    profileImplementation 'com.example.test_flutter_module_0418:flutter_profile:1.0'
    // 在 profile 构建类型中添加 Flutter 模块的 profile 版本依赖
    releaseImplementation 'com.example.test_flutter_module_0418:flutter_release:1.0'
    // 在 release 构建类型中添加 Flutter 模块的 release 版本依赖
}

Flutter 学习之旅 之 Flutter 和 Android 原生 实现数据交互的MethodChanel和EventChannel方式的简单整理