Flutter‑Android Hybrid Integration: Mixed Modules, Engine Management, Architecture, Debugging and Packaging

1. Introduction

The article revisits a Flutter data‑form module that was rebuilt after months of development, summarizing the challenges of mixing Flutter with native Android code.

2. Mixed Integration Options

Two primary ways to embed Flutter are described: source integration (adding the Flutter module as a sub‑project) and AAR integration (building an AAR package). Both methods are illustrated with Gradle configuration snippets.

setBinding(new Binding([gradle: this]))

evaluate(new File(settingsDir.parentFile, 'flutter模块/.android/include_flutter.groovy'))

Source integration requires adding the Flutter module to settings.gradle and configuring the Flutter SDK path, while AAR integration uses flutter build aar to generate debug, release, and profile AARs.

3. Hybrid Stack Management

The article compares single‑engine and multi‑engine strategies, introduces FlutterEngineGroup for shared resources, and shows how to pre‑warm a FlutterEngine in a custom Application class.

class MyApp : Application() {
    lateinit var engines: FlutterEngineGroup
    override fun onCreate() {
        super.onCreate()
        engines = FlutterEngineGroup(this)
    }
}

It also covers the use of flutter_boost (single‑engine) and flutter_thrio (single/multi‑engine) for navigation, providing code examples for method‑channel communication and route handling.

4. Architecture & State Management

The author advocates an MVVM pattern with Riverpod, presenting a simple counter example and a more complex ListView with immutable models, copyWith() , and per‑item providers to avoid full list rebuilds.

class CounterViewModel {
    final CounterModel _model = CounterModel();
    Function? _onChanged;
    int get counter => _model.counter;
    void increment() {
        _model.increment();
        _onChanged?.call();
    }
    void addListener(Function listener) => _onChanged = listener;
    void removeListener() => _onChanged = null;
}

5. Debugging

Instructions for hot‑reload using flutter attach and for attaching a debugger in Android Studio are provided, with screenshots of the console output.

6. Packaging APK

Two packaging approaches are detailed: source integration with a CI script that pulls the latest Flutter module and builds it before the Android app, and AAR integration with Maven deployment of multiple AARs or using the fat-aar-android plugin to merge them into a single AAR.

flutter build aar
# Find all release AARs and deploy to a local Maven repo
find $REPO_DIR -type f -name "*.aar" | grep 'release-.*\.aar$' | while read aar; do
    mvn deploy:deploy-file -Dfile="$aar" -DgroupId="cn.coderpig" -DartifactId="mylibrary" -Dversion="1.0.0" -Dpackaging=aar -Durl=file://$LOCAL_REPO_PATH
 done

7. Conclusion

The author reflects on the lessons learned, emphasizing the importance of proper process checks, engine initialization, and state management to avoid common pitfalls in Flutter‑native hybrid projects.