Find out how to Android Integration in native projects Flutter

Specific operation

Build configuration
Execute the command at the root of the native project flutter create -t module --org {package_name} {module_name} // here
module_name Follow your orders Android son module Just name it . There must be no middle line . // such as , flutter create -t
module --org flutter_sub // here module_name Follow your orders
Android son module Just name it . There must be no middle line . // such as , flutter create -t module --org flutter_sub </pre>
<pre class="prettyprint hljs groovy" style="padding: 0.5em; font-family:
Menlo, Monaco, Consolas, "Courier New", monospace; color: rgb(68, 68,
68); border-radius: 4px; display: block; margin: 0px 0px 1.5em; font-size:
14px; line-height: 1.5em; word-break: break-all; overflow-wrap: break-word;
white-space: pre; background-color: rgb(246, 246, 246); border: none;
overflow-x: auto;">Creating project sub_flutter...
sub_flutter/test/widget_test.dart (created) sub_flutter/sub_flutter.iml
(created) sub_flutter/.gitignore (created) sub_flutter/.metadata (created)
sub_flutter/pubspec.yaml (created) sub_flutter/ (created)
sub_flutter/lib/main.dart (created) sub_flutter/sub_flutter_android.iml
(created) sub_flutter/.idea/libraries/Dart_SDK.xml (created)
sub_flutter/.idea/modules.xml (created) sub_flutter/.idea/workspace.xml
(created) Running "flutter pub get" in sub_flutter... 1,054ms Wrote 11 files.
Finally, the above documents are generated , Notice the end here   Automatically flutter pub get  Your orders . about flutter pub get What did you do , You can refer to the following .

Here, create a child in the root of the project module Just to put the code in a warehouse , Easy maintenance , In theory, it can be placed anywhere on the hard disk .

Configure native project settings.gradle

In configuration settings.gradle Let's first briefly review the Gradle Some basic knowledge of .

If you know Gradle Related configuration , There must be a concept , namely   Convention is better than configuration  , What do you mean , According to the idea of object-oriented to understand , Every project is a huge one
Project class , There are many properties in the whole class . And every project we create is actually a concrete project Project object ( That's an example ). Agreement is better than configuration , That's right
project When instantiating , Its internal properties already have default values . So how do we know what the default values are ? Execute in the project root directory
./gradlew properties
You can get the whole thing Project Some default configurations of , such as ( Some results are excerpted here )
------------------------------------------------------------ Root project
------------------------------------------------------------ allprojects: [root
project 'MiniApp', project ':app', project ':thirdlib']
android.agp.version.check.performed: true android.enableJetifier: true
android.enableR8: true android.enableR8.libraries: true android.useAndroidX:
true buildDir: /Users/username/Documents/mygithub/MinApp/build buildFile:
/Users/username/Documents/mygithub/MinApp/build.gradle projectDir:
/Users/username/Documents/mygithub/MinApp rootDir:
/Users/username/Documents/mygithub/MinApp rootProject: root project 'MiniApp'
Here are some of our current configurations , such as useAndroidX, But there are also agreements , such as For the whole project For buildDir It's the root of the project
build Folder, etc .

./gradlew :app:properties
Excerpts of some results
buildDir: /Users/username/Documents/mygithub/MinApp/app/build buildFile:
You'll get information about it app whole module Some configuration information at this stage , Of course, the configuration information is different from the Convention , And your own configuration , such as buildToolsVersion
, Signature and other related information . You can see that buildDir And the whole thing project It's not the same .

Back to the theme , Let's see how to put the sub_flutter Modules are integrated into the project .( Strictly speaking, it's not integration sub_flutter modular , Because he's just one
flutter Module for , And in Android The main project can only integrate sub projects Android module, So how to make specific changes , Let's take a look at the mystery )

According to the official method of operation , We will be asked to add the following configuration to the settings.gradle in .
// Include the host app project. include ':app' // assumed existing content
setBinding(new Binding([gradle: this])) // new evaluate(new File( // new
settingsDir.parentFile, // new 'my_flutter/.android/include_flutter.groovy' //
new )) // new
First look there settingsDir Value of . stay settings.gradle Add directly in
println "settings.dir=" + settingsDir println "settings.dir.parent=" +
sync Then you see the output
therefore , Configuration information above , That is to say, combination settings The parent directory of the directory is combined with our configured directory , Found one named include_flutter.groovy
File for , Then go and execute him .

I said that , Create child module When I was young , It can be in the project root directory , It can also be in other places , If it's in another location , there my_flutter
It can be replaced by the absolute strength of your directory .

This is created directly in the root directory , Then the above configuration can be simplified to
setBinding(new Binding([gradle: this])) evaluate(new File(settingsDir,
'sub_flutter/.android/include_flutter.groovy')) include ':sub_flutter' #### about
It says so ,settings.gradle Configuration of , In fact, it is to carry out include_flutter.groovy This document , You can take a brief look at this file
def scriptFile = getClass().protectionDomain.codeSource.location.toURI() def
flutterProjectRoot = new File(scriptFile).parentFile.parentFile gradle.include
":flutter" gradle.project(":flutter").projectDir = new File(flutterProjectRoot,
".android/Flutter") def localPropertiesFile = new File(flutterProjectRoot,
".android/") def properties = new Properties() assert
localPropertiesFile.exists(), ":exclamation:️The Flutter module doesn't have a
`$localPropertiesFile` file." + "\nYou must run `flutter pub get` in
`$flutterProjectRoot`." localPropertiesFile.withReader("UTF-8") { reader ->
properties.load(reader) } def flutterSdkPath =
properties.getProperty("flutter.sdk") assert flutterSdkPath != null,
"flutter.sdk not set in" gradle.apply from:
.android In fact, it is one Android project , He contains one Flutter folder , this Flutter It's a library Type Android
module , This point comes from his build.gradle As can be seen from the documents . include_flutter.groovy What we did , It's about putting the current
library Named flutter One of them moudle. Then check the project in sdk Related configuration of , Finally, it's time to execute
FlutterSDK Of gradle script , Here, the specific analysis is no longer carried out .

in other words , Now there's one called flutter Of Android Library Module . this module contain flutter
All configurations of . If we rely on this module , So it's like dependence Flutter .

rely on flutter

Finally, in the context of the native project application-module Of build.gradle Of dependencies Add to closure
implementation project(':flutter')
thus , Native projects already exist Flutter The dependence of , have access to Flutter Of View It's over .

thus , Now the native project contains Flutter SDK It's all dependent on you ,UI Related content , How to write or use dart stay main.dart
Written in Chinese , And then we can take this dart The rendered content is in accordance with the Activity ,Fragment or View Added to an existing project in the form of .

flutter pub get

flutter pub get perhaps pub get What are you doing flutter When using a third party lib
You often use a command when you update a file or version , This command will pull related dependencies , In fact, this command will be generated automatically Android and iOS Native project of . For example, when we created it
sub_flutter In the module , Are generated automatically .android and .ios Native project directory for . At the same time, these two directories start with a dot , In general, it is to hide the file , At the same time
.gitignore The file can also be seen , about flutter module In form , Both of these folders are ignored , after all flutter module
The core of , Or for convenience module Integrated into native projects in the form of , Two native directories inside , One is to facilitate integration , On the other hand, it is easy to run directly hot-reload
Debugging of .