mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
Almost all of the code is just adopting to changes to the APIs of `package:native_assets_builder`, `package:native_assets_cli` and `package:native_toolchain_c` There's only two semantic changes * Removes a test that checks for a verification error if a build hook produces a static library if the preferred linking mode is dynamic: => The test is written in a very hacky way. By monkey patching the build config.json that flutter build actually made. This monkey patching relies on package:cli_config which is now no longer used. => The actual code that checks for this mismatch lives in dart-lang/native repository and is tested there. So there's really no need to duplicate that. * The `package:native_assets_builder` no longer knows about code assets. This is something a user of that package (e.g. flutter tools) adds. Now the dry-run functionality will invoke build hooks who produce code assets without an architecture. => The `package:native_assets_builder` used to expand such a code asset to N different code assets (one for each supported architecture) => This logic was now moved to flutter tools. => In the near future we're going to this dry-run complexity, which will then also get rid of this uglyness (of expanding to all archs of an OS).
# {{projectName}}
{{description}}
## Getting Started
This project is a starting point for a Flutter
[FFI package](https://flutter.dev/to/ffi-package),
a specialized package that includes native code directly invoked with Dart FFI.
## Project structure
This template uses the following structure:
* `src`: Contains the native source code, and a CmakeFile.txt file for building
that source code into a dynamic library.
* `lib`: Contains the Dart code that defines the API of the plugin, and which
calls into the native code using `dart:ffi`.
* `bin`: Contains the `build.dart` that performs the external native builds.
## Building and bundling native code
`build.dart` does the building of native components.
Bundling is done by Flutter based on the output from `build.dart`.
## Binding to native code
To use the native code, bindings in Dart are needed.
To avoid writing these by hand, they are generated from the header file
(`src/{{projectName}}.h`) by `package:ffigen`.
Regenerate the bindings by running `dart run ffigen --config ffigen.yaml`.
## Invoking native code
Very short-running native functions can be directly invoked from any isolate.
For example, see `sum` in `lib/{{projectName}}.dart`.
Longer-running functions should be invoked on a helper isolate to avoid
dropping frames in Flutter applications.
For example, see `sumAsync` in `lib/{{projectName}}.dart`.
## Flutter help
For help getting started with Flutter, view our
[online documentation](https://docs.flutter.dev), which offers tutorials,
samples, guidance on mobile development, and a full API reference.