text stringlengths 1 474 |
|---|
described.Fundamentally, the Flutter framework on the Dart side requires access to various |
activity-level events and lifecycles to function. Since the FlutterView (which |
is an android.view.View) |
can be added to any activity which is owned by the developer’s application |
and since the FlutterView doesn’t have access to activity level events, the |
developer must bridge those connections manually to the FlutterEngine.How you choose to feed your application’s activities’ events to the FlutterView |
will be specific to your application.<topic_end> |
<topic_start> |
A sample |
Unlike the guides for FlutterActivity and FlutterFragment, the FlutterView |
integration could be better demonstrated with a sample project.A sample project is at https://github.com/flutter/samples/tree/main/add_to_app/android_view |
to document a simple FlutterView integration where FlutterViews are used |
for some of the cells in a RecycleView list of cards as seen in the gif above.<topic_end> |
<topic_start> |
General approach |
The general gist of the FlutterView-level integration is that you must recreate |
the various interactions between your Activity, the FlutterView |
and the FlutterEngine |
present in the FlutterActivityAndFragmentDelegate |
in your own application’s code. The connections made in the FlutterActivityAndFragmentDelegate |
are done automatically when using a FlutterActivity |
or a FlutterFragment, |
but since the FlutterView |
in this case is being added to an Activity or Fragment in your application, |
you must recreate the connections manually. Otherwise, the FlutterView |
will not render anything or have other missing functionalities.A sample FlutterViewEngine |
class shows one such possible implementation of an application-specific |
connection between an Activity, a FlutterView |
and a FlutterEngine.<topic_end> |
<topic_start> |
APIs to implement |
The absolute minimum implementation needed for Flutter to draw anything at all |
is to:The reverse detachFromFlutterEngine and other lifecycle methods on the LifecycleChannel |
class must also be called to not leak resources when the FlutterView or Activity |
is no longer visible.In addition, see the remaining implementation in the FlutterViewEngine |
demo class or in the FlutterActivityAndFragmentDelegate |
to ensure a correct functioning of other features such as clipboards, system |
UI overlay, plugins etc. |
<topic_end> |
<topic_start>Manage plugins and dependencies in add-to-app |
This guide describes how to set up your project to consume |
plugins and how to manage your Gradle library dependencies |
between your existing Android app and your Flutter module’s plugins.<topic_end> |
<topic_start> |
A. Simple scenario |
In the simple cases:There are no additional steps needed. Your add-to-app |
module will work the same way as a full-Flutter app. |
Whether you integrate using Android Studio, |
Gradle subproject or AARs, |
transitive Android Gradle libraries are automatically |
bundled as needed into your outer existing app.<topic_end> |
<topic_start> |
B. Plugins needing project edits |
Some plugins require you to make some edits to the |
Android side of your project.For example, the integration instructions for the |
firebase_crashlytics plugin require manual |
edits to your Android wrapper project’s build.gradle file.For full-Flutter apps, these edits are done in your |
Flutter project’s /android/ directory.In the case of a Flutter module, there are only Dart |
files in your module project. Perform those Android |
Gradle file edits on your outer, existing Android |
app rather than in your Flutter module.info Note |
Astute readers might notice that the Flutter module |
directory also contains an .android and an |
.ios directory. Those directories are Flutter-tool-generated |
and are only meant to bootstrap Flutter into generic |
Android or iOS libraries. They should not be edited or checked-in. |
This allows Flutter to improve the integration point should |
there be bugs or updates needed with new versions of Gradle, |
Android, Android Gradle Plugin, etc.For advanced users, if more modularity is needed and you must |
not leak knowledge of your Flutter module’s dependencies into |
your outer host app, you can rewrap and repackage your Flutter |
module’s Gradle library inside another native Android Gradle |
library that depends on the Flutter module’s Gradle library. |
You can make your Android specific changes such as editing the |
AndroidManifest.xml, Gradle files or adding more Java files |
in that wrapper library.<topic_end> |
<topic_start> |
C. Merging libraries |
The scenario that requires slightly more attention is if |
your existing Android application already depends on the |
same Android library that your Flutter module |
does (transitively via a plugin).For instance, your existing app’s Gradle might already have: |
<code_start>… |
dependencies { |
… |
implementation 'com.crashlytics.sdk.android:crashlytics:2.10.1' |
… |
} |
…<code_end> |
And your Flutter module also depends on |
firebase_crashlytics via pubspec.yaml: |
<code_start>… |
dependencies: |
… |
firebase_crashlytics: ^0.1.3 |
… |
…<code_end> |
This plugin usage transitively adds a Gradle dependency again via |
firebase_crashlytics v0.1.3’s own Gradle file: |
<code_start>… |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.