Description:

unify flutter

Unify: Flutter-Native Hybrid Communication Framework #
中文说明
Unify is an efficient, flexible, and easy-to-use Flutter hybrid development framework designed to solve communication issues between Flutter and native modules. It supports platform-independent module abstraction, flexible implementation injection, automatic code generation, and other features, significantly improving the efficiency of hybrid development and reducing maintenance costs.
Unify is developed by Didi's international food delivery team and has been widely used in Didi's international food delivery and international travel business, effectively supporting the Flutter-based development process.
Key features:

Platform-independent module abstraction: Allows developers to declare platform-independent module interfaces and entities using the Dart language.
Flexible implementation injection: Developers can flexibly choose to inject native implementations (Android/iOS) or Flutter implementations.
Automatic code generation: With a powerful code generation engine, Unify can automatically generate SDKs for unified calls across Flutter, Android, and iOS platforms.

Here's an example of declaring a native module using Unify:
@UniNativeModule()
abstract class DeviceInfoService {
Future<DeviceInfoModel> getDeviceInfo();
}
copied to clipboard
Through Unify, the above Dart interface can be automatically mapped to Android and iOS platforms, and developers only need to focus on the specific implementation on each platform. When used in Flutter, the calling method is as simple and intuitive as a regular Flutter module:
DeviceInfoService.getDeviceInfo().then((deviceInfoModel) {
print("${deviceInfoModel.encode()}");
});
copied to clipboard
The overall principle of Unify is as follows:

Unify can effectively solve some common problems in Flutter hybrid development, such as:

Efficiently importing a large number of native modules into Flutter
Efficiently importing a large number of Flutter modules into native code
Solving the maintenance issue of a large number of channels
Hybrid architecture layering with coexistence of native and Flutter

Start using Unify now to make hybrid development more efficient!
Installation #
Unify is a command developed using Dart.
Add dev_dependencies in the pubspec.yaml of your Flutter project:
dev_dependencies:
unify_flutter: ^3.0.0
copied to clipboard

Note: pub.dev: https://pub.dev/packages/unify_flutter

Git dependency:
dev_dependencies:
unify_flutter:
git: git@github.com:maxiee/Unify.git
copied to clipboard
Run flutter pub get to pull the dependencies. Then you can run Unify:
flutter pub run unify_flutter api
copied to clipboard

Note: Running the Unify command usually requires a series of parameters. For specific usage, please refer to Getting Started.

Getting Started #
Follow these steps to quickly start using Unify to uniformly encapsulate a native SDK (including Android and iOS versions) and import it into Flutter.

Reference example code: example/01_uninativemodule_demo

Prerequisites #
Before getting started, make sure your development environment meets the following conditions:

Flutter 3 or above is installed
For Android development, the Android development environment is configured
For iOS development, the iOS development environment is configured

Step 1: Clone the Example Project #
First, clone the Unify project and enter the example directory:
git clone git@github.com:didi/Unify.git
cd ./Unify/01_uninativemodule_demo
copied to clipboard
01_uninativemodule_demo is a standard Flutter app project. Its features include:

The native side (Android/iOS) implements a system information module respectively
Use Unify to uniformly encapsulate native modules and import them into Flutter
Perform unified calls on the Flutter side

Step 2: Declare Unify Module #
Notice that there is an interface directory in the project root, which is where Unify modules are declared. It contains two files:

device_info_service.dart - Declares the native module:

// device_info_service.dart
@UniNativeModule()
abstract class DeviceInfoService {
/// Get device information
Future<DeviceInfoModel> getDeviceInfo();
}
copied to clipboard
The @UniNativeModule annotation indicates that the implementation of this module is provided by the native side.

device_info_model.dart - Declares the return value model:

// device_info_model.dart
@UniModel()
class DeviceInfoModel {
/// Operating system version
String? osVersion;

/// Memory information
String? memory;

/// Device model
String? platform;
}
copied to clipboard
The @UniModel annotation indicates that this is a cross-platform data model.
Step 3: Generate Cross-Platform Code #
After completing the interface declaration, execute the following command to generate cross-platform code:
flutter pub run unify_flutter api\
--input=`pwd`/interface \
--dart_out=`pwd`/lib \
--java_out=`pwd`/android/src/main/java/com/example/uninativemodule_demo \
--java_package=com.example.uninativemodule_demo \
--oc_out=`pwd`/ios/Classes \
--dart_null_safety=true \
--uniapi_prefix=UD
copied to clipboard
Command option description:



Parameter
Description
Required




input
Specifies the Unify interface declaration directory
Y


dart_out
Specifies the Dart code output directory
Y


java_out
Specifies the Java code output directory
Android


java_package
Specifies the package name of the generated Java code
Android


oc_out
Specifies the Objective-C code output directory
iOS


dart_null_safety
Whether to generate null-safe Dart code
Y


uniapi_prefix
Generated code prefix to avoid conflicts between libraries
N



After execution, Unify generates code for each platform in the corresponding directory.
Step 4: Implement Native Modules #
We need to provide the specific implementation for the generated native module interfaces:


Android platform implementation class: DeviceInfoServiceImpl.java


Android platform implementation registration: MainActivity.java


iOS platform implementation class: DeviceInfoServiceVendor.h, DeviceInfoServiceVendor.m


iOS platform implementation registration: AppDelegate.m


You can refer to the example code for implementation.
Step 5: Call in Flutter #
Everything is ready! In the Flutter code, you can now directly call the native module encapsulated by Unify:
OutlinedButton(
child: const Text("Get Device Info"),
onPressed: () {
DeviceInfoService.getDeviceInfo().then((deviceInfoModel) {
setState(() {
_platformVersion = "\n${deviceInfoModel.encode()}";
});
});
},
),
copied to clipboard

At this point, you have successfully imported a native module using Unify and used it in Flutter. It's as simple and intuitive as calling a Flutter module!
Summary #
Through this example, we experienced the value brought by Unify:

Unified Module Declaration: Unified module interface declaration on any platform to avoid inconsistent implementations
UniModel: Supports cross-platform transparent data model transmission
Compared to Flutter's native channel approach:

Avoids errors caused by manual parameter parsing
Automatic alignment between Android and iOS
Automatic generation of a large number of channels, easy to maintain
Seamless serialization of complex entities, reducing management costs



Decision Tree #
We have summarized the following decision-making process:

More Examples #
In Getting Started, we provided the most basic and commonly used scenario of importing native implementations into Flutter. Unify's capabilities go far beyond that. From simple single SDK encapsulation to complex enterprise-level app large-scale module export, Unify can support it all.
We introduce these typical scenarios and business models through example applications:



Case
Description
Applicable Scenario




01_uninativemodule_demo
UniNativeModule demo
How to efficiently import a native module (Android/iOS dual-end implementation) into Flutter and achieve unified calling


02_unifluttermodule_demo
UniFlutterModule demo
How to efficiently import a Flutter module into native (Android/iOS) and achieve unified calling



Documentation #
For more advanced usage, please refer to the detailed documentation.

For documentation, please refer to Unify Documentation.
To quickly experience how to use it, please refer to Getting Started.
To understand the capabilities provided by Unify, please refer to Basic Capabilities.
To understand the design principles of Unify modules, please refer to Principle Overview.
For more usage instructions of Unify CLI, please refer to CLI Usage Tutorial.


Note: We are also actively organizing the documentation. If you have any questions regarding usage or understanding, please feel free to submit an issue for feedback and discussion!

License #

Unify is distributed and used under the Apache-2.0 license. For more information, see the License File.
Members #
R&D Team:
maxiee,
zhugeafanti,
piglet696,
zhaoxiaochun,
ChengCheng-Hello,
windChaser618,
bql88601485,
newbiechen1024,
xizhilang66,
UCPHszf,
QianfeiSir,
jiawei1203,
Whanter
Contribution #
If you have any questions regarding usage or understanding, please feel free to submit an issue for feedback and discussion!
Your communication and contributions are welcome!

License

For personal and professional use. You cannot resell or redistribute these repositories in their original state.

Share

• Share on Facebook
• Share on Twitter