在 Android的开发中,我们有 JNI 使得 Java可以调用本地应用或库。
Flutter 在前不久发布了 Flutter2,更新了 FFI (我们是否可以把它叫做DNI呢?)进入了稳定状态,开发者可以更安心的使用其功能。
但是相关的文档依然很欠缺,导致使用起来有诸多的疑问,以及相关原理性的介绍比较少,所以整理记录一下。

一、Dart 同步调用 Native 方法

我们以最简单的demo为例,请求一个有参无返回值的C方法
在 C/C++中有如下函数:

1
2
3
4
5
extern "C" __attribute__((visibility("default"))) __attribute__((used))

void c_with_out_return_value(int value) {
LOG_D("Got invoke value: %d", value);
}

Dart:

1
2
3
4
final DynamicLibrary ffiLib = Platform.isAndroid ? DynamicLibrary.open('lib_invoke.so') : DynamicLibrary.process();

final cMethod = ffiLib.lookupFunction<Void Function(Int32 value), void Function(int value)>('c_with_out_return_value');
cMethod(123);

这样一次调用就完成了一次调用,传递了123到Native并执行了一次打印,同理相关有参有返回值的请求也都是这样做到的,那 Dart 和 Native内部具体怎样实现的呢?

DynamicLibrary.open() 最终执行的逻辑如下, 源码位于ffi_dynamic_library.cc

1
2
3
4
5
6
7
8
9
10
11
12
static void* LoadExtensionLibrary(const char* library_file) {
#if defined(HOST_OS_LINUX) || defined(HOST_OS_MACOS) || \
defined(HOST_OS_ANDROID) || defined(HOST_OS_FUCHSIA)
void* handle = dlopen(library_file, RTLD_LAZY);
if (handle == nullptr) {
char* error = dlerror();
const String& msg = String::Handle(
String::NewFormatted("Failed to load dynamic library (%s)", error));
Exceptions::ThrowArgumentError(msg);
}
return handle;
……

可以看到最终使用 dlopen 加载动态链接库,并返回句柄。

拿到对应的动态链接库的句柄之后,就能使用相关方法进行操作了。
句柄主要包含以下两个方法:

1
2
3
4
5
6
//在内存中查找对应符号名的地址,与dlsym()功能相同
external Pointer<T> lookup<T extends NativeType>(String symbolName);

//1、去动态库中查找对应名称的函数
//2、将 Native 类型的 C/C++ 函数转化为 Dart 的 Function 类型
external F lookupFunction<T extends Function, F extends Function>(String symbolName);

其中lookup()的最终实现主要使用了 dlsym

1
2
3
4
5
6
7
8
9
10
11
12
static void* ResolveSymbol(void* handle, const char* symbol) {
#if defined(HOST_OS_LINUX) || defined(HOST_OS_MACOS) ||
defined(HOST_OS_ANDROID) || defined(HOST_OS_FUCHSIA)
dlerror(); // Clear any errors.
void* pointer = dlsym(handle, symbol);
if (pointer == nullptr) {
char* error = dlerror();
const String& msg = String::Handle(
String::NewFormatted("Failed to lookup symbol (%s)", error));
Exceptions::ThrowArgumentError(msg);
}
return pointer;

二、Dart 异步调用 Native 方法

在很多场景我们不能像上述同步方法那样,dart 进行一次请求之后立马得到结果,可能会有一些耗时操作,为了不让 Flutter 的UI线程卡住,我们进行异步请求。那如何实现异步请求呢?
对于异步实现,官方并没有很明确的文档,都得靠自己琢磨,在官方的讨论中 https://github.com/dart-lang/sdk/issues/37022 以及 https://github.com/flutter/flutter/issues/63255 提到一些解决方案:

1.In your C++ code include include/dart_api_dl.h and include/dart_api_dl.cc from here https://github.com/dart-lang/sdk/blob/master/runtime/include/ (they also depend on include/internal/*).

2.From Dart call Dart_InitializeApiDL passing NativeApi.initializeApiDLData as an argument.

3.On Dart side create a ReceivePort and pass port number of the corresponding SendPort to the native side (port.sendPort.nativePort).

4.Now on C++ side you can use Dart_PostCObject_DL to send messages back to Dart side from any thread.

按上述的操作进行实现,接下来具体分析一些里面的逻辑原理。
1、导入include/dart_api_dl.h include/dart_api_dl.cc 相关的文件并在 CMakeList.txt进行相关配置
2、从dart中 调用Native中 Dart_InitializeApiDL

Dart:

1
2
3
4
void main() {
initializeApi(NativeApi.initializeApiDLData);
runApp(MyApp());
}

C++:

1
2
3
4
5
// Initialize `dart_api_dl.h`
DART_EXPORT intptr_t InitDartApiDL(void *data) {
LOG_D("InitDartApiDL");
return Dart_InitializeApiDL(data);
}

在 initializeApi(NativeApi.initializeApiDLData) 中 initializeApi 向 Native请求 DART_EXPORT intptr_t InitDartApiDL(void *data)方法,传入的参数就是在 dart_api_dl.h
DART_NATIVE_API_DL_SYMBOLS 以及 DART_API_DL_SYMBOLS 中的方法。

NativeApi.initializeApiDLData 逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
13
static const DartApiEntry dart_api_entries[] = {
#define ENTRY(name, R, A) \
DartApiEntry{#name, reinterpret_cast<void (*)()>(name)},
DART_API_ALL_DL_SYMBOLS(ENTRY)
#undef ENTRY
DartApiEntry{nullptr, nullptr}};

static const DartApi dart_api_data = {
DART_API_DL_MAJOR_VERSION, DART_API_DL_MINOR_VERSION, dart_api_entries};

DEFINE_NATIVE_ENTRY(DartApiDLInitializeData, 0, 0) {
return Integer::New(reinterpret_cast<intptr_t>(&dart_api_data));
}

dart_api_dl中定义的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define DART_NATIVE_API_DL_SYMBOLS(F)                                          \
/***** dart_native_api.h *****/ \
/* Dart_Port */ \
F(Dart_PostCObject, bool, (Dart_Port_DL port_id, Dart_CObject * message)) \
F(Dart_PostInteger, bool, (Dart_Port_DL port_id, int64_t message)) \
.....

// dart_api.h symbols can only be called on Dart threads.
#define DART_API_DL_SYMBOLS(F) \
/***** dart_api.h *****/ \
/* Errors */ \
F(Dart_IsError, bool, (Dart_Handle handle)) \
F(Dart_IsApiError, bool, (Dart_Handle handle)) \
.....

其实这上面的逻辑很简单,主要是为了让业务中的代码能够进行动态链接,从而调用到 Flutter SDK 中相关方法。

3、第三步添加 ReceivePort 监听

1
2
3
4
5
6
7
8
9
class Work extends Opaque {}

void requestExecuteCallback(dynamic message) {
final int workAddress = message as int;
final Pointer<Work> work = Pointer<Work>.fromAddress(workAddress);
executeCallback(work);
}

final ReceivePort interactiveCppRequests = ReceivePort()..listen(requestExecuteCallback);

向 Native 发送带有 interactiveCppRequests.sendPort.nativePort 的数据,为native异步回调做准备。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Future<int> platformAsync(int value1, int value2) {
final Completer<int> completer = Completer<int>();
final String cid = uuid.v1();
final Pointer<Utf8> cidPtr = cid.toNativeUtf8();
completerMapping[cid] = completer;
//生成一个nativePort,为native异步回调做准备
final int nativePort = interactiveCppRequests.sendPort.nativePort;

final cMethod = ffiLib.lookupFunction<
Int32 Function(Pointer<Utf8> cId, Int64 sendPort, Int32 value1, Int32 value2,
Pointer<NativeFunction<callback_type>> callbackBlock),
int Function(Pointer<Utf8> cId, int sendPort, int value1, int value2,
Pointer<NativeFunction<callback_type>> callbackBlock)>('platform_async');

cMethod(cidPtr, nativePort, value1, value2, Pointer.fromFunction<callback_type>(_callbackBlocking));
return completer.future;
}

4、当异步执行完成之后,在 Native 执行 Dart_PostCObject_DL 通知 Dart 已经得到结果
对于代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void response(jint result) {
Work work = [_callback,result] {
if (_callback != nullptr) {
_callback( result);
} else {
LOG_E("_callback == null");
}
};
// Copy to heap to make it outlive the function scope.
const Work *work_ptr = new Work(work);
NotifyDart(send_port, work_ptr);
}

void NotifyDart(Dart_Port send_port, const Work *work) {
const auto work_address = reinterpret_cast<intptr_t>(work);
Dart_CObject dart_object;
dart_object.type = Dart_CObject_kInt64;
dart_object.value.as_int64 = work_address;

const bool result = Dart_PostCObject_DL(send_port, &dart_object);
if (!result) {
LOG_D("FFI C : Posting message to port failed.");
}
}

上面的代码最核心的就是Dart_PostCObject_DL()这里真正调用的还是,Dart_PostCObject(),加_DL()表示动态链接的方法,为了防止与原先符号冲突。

All symbols are postfixed with _DL to indicate that they are dynamically

linked and to prevent conflicts with the original symbol.

我们继续看看 Dart_PostCObject()真正做了什么,Dart_PostCObject()最终调用的方法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13

static bool PostCObjectHelper(Dart_Port port_id, Dart_CObject* message) {
ApiMessageWriter writer;
std::unique_ptr<Message> msg =
writer.WriteCMessage(message, port_id, Message::kNormalPriority);

if (msg == nullptr) {
return false;
}

// Post the message at the given port.
return PortMap::PostMessage(std::move(msg));
}

这里在向 Service Isolate发送事件,最终 Dart 成功接受到异步消息的回调。
关于 Isolate 这一块的处理可以参考:Async Coding With Dart: Isolates

三、Native 调用 Dart方法 ?

对于 JNI 里面,我们需要调用 Java的方法,利用Java反射机制调用即可,如下所示:

1
_env->CallStaticVoidMethod(j_class, j_method, arg1, arg2);

如果 Native 想要调用 Dart代码有类似的代码可以用么?翻遍了 Flutter相关的文档,都没有找到对应的方法可以直接去调用 Dart的方法,Dart Engine内部有 dart_api.h提供了Dart_invoke()方法,但单纯的导入 .h文件在项目中是无法链接到对应的方法的,这也就是为什么需要导入ffi_runtime_lib相关的文件并执行 Dart_InitializeApiDL(),通过动态链接使得代码能够去调用 Dart 封装的相关方法。

所以参考 Dart中 InitDartApiDL的方法,我们先对 Dart 中的函数进行注册,传递对应方法的指针,然后在 Native 中即可调用,理论上可行,后续会补上相关 demo。
当然这只是一种骚操作,如果有更好的方法能够用 Native 调用 Dart 欢迎讨论。

四、总结

文章记录了 Dart 同步和异步调用 Native 相关的使用,异步具体的使用比上述的代码复杂,因为需要一个中介记录异步相关的回调方法,当得到真正的结果之后,利用id查找到对应的方法再执行回调方法。FFI 在 Native中执行 dart 方法,暂时没有比较好的解决方案
FFI 调用可查看 Demo flutter_ffi_tutorial