Flutter Android Embedding V1与V2的区别是什么？插件开发相关疑问

Hey there! Let me break down Flutter Android Embedding V1 and V2 for you, especially since you're working with background functionality in a Flutter plugin (like android_alarm_manager).

First, let's clarify what an "Android Embedding" even is: it's the core layer that acts as a bridge between your Flutter code and the Android native system. It handles critical stuff like initializing the Flutter engine, managing lifecycle events, and enabling communication between Flutter and Android plugins.

V1 is the original embedding system that shipped with early versions of Flutter. It's built around a more rigid, activity-centric architecture:

• It requires your Android app to inherit from FlutterActivity or FlutterFragment to host Flutter content.
• Plugin registration is tied to the PluginRegistry instance linked to your Flutter activity/fragment.
• For background tasks (like the isolated zones used by android_alarm_manager), this becomes a problem: since there's no active activity context in the background, the plugin can't auto-register itself. That's exactly why the android_alarm_manager README mentions needing a callback to manually register plugins in the background isolate—V1 doesn't handle this automatically.

Introduced in Flutter 1.12, V2 is a complete rewrite of the embedding layer designed to align with modern Android best practices (like AndroidX support and flexible component integration). It's the official recommended approach now, and all new Flutter projects use it by default.

• It centers around the FlutterEngine class: a standalone, reusable instance that holds the Flutter runtime, plugins, and rendering context.
• Plugin registration is directly tied to a FlutterEngine instance, not an activity or fragment. This makes it way easier to use Flutter in non-activity contexts (like background services or broadcast receivers).

Key Differences Between V1 and V2 #

Let's break down the most impactful differences, especially for your background plugin work:

• Architecture Flexibility
  • V1: Tightly couples Flutter to an activity/fragment—you can't easily share a single Flutter engine across multiple screens or use Flutter in non-activity components without hacks.
  • V2: FlutterEngine instances are independent. You can initialize an engine at the app level (when your app starts) and reuse it across activities, or spin up a dedicated engine for background tasks. This is a game-changer for modular Android apps.
• Plugin Registration in Background Contexts
  • V1: Background isolates/services have no access to the activity-linked PluginRegistry, so you must set a plugin registrant callback (like BackgroundExecutor.setPluginRegistrantCallback()) to manually register plugins in the background. Without this, your plugin calls in the background will fail.
  • V2: Since plugins are registered to a FlutterEngine, you can create a dedicated engine for your background task, register the necessary plugins directly on it, and run your Flutter code. No extra callback setup is required—just manage the engine's lifecycle properly.
• Lifecycle Control
  • V1: The Flutter engine's lifecycle is tied directly to the host activity. When the activity is destroyed, the engine is destroyed too—no way to keep it alive for background work.
  • V2: You have full control over the FlutterEngine lifecycle. You can keep an engine running in the background even when all activities are closed, or destroy it when it's no longer needed.
• AndroidX Support
  • V1: Has limited, clunky support for AndroidX, often leading to dependency conflicts and setup headaches.
  • V2: Natively supports AndroidX, which is required for most modern Android libraries and features.
• Plugin Compatibility
  • V1: Older plugins may only support V1, but most modern plugins have dropped V1 support entirely.
  • V2: All new official and community plugins target V2, and it's the only embedding system actively maintained by Flutter.

If you're building a new Flutter plugin with background functionality, go all-in on V2. It simplifies background task handling, integrates better with modern Android apps, and is the future-proof choice. V1 is essentially deprecated at this point, so you'll avoid a lot of headaches by sticking with V2.

内容的提问来源于stack exchange，提问作者Mahdi-Malv