全面解析Flutter Platform Channel原理

快来打我* 2022-12-25 10:53 76阅读 0赞

## 前言 ##

我们知道Flutter中通过Platform Channel实现Flutter和原生端的数据传递，那么这些数据是怎么传递的，传递的过程都做了哪些操作，本文将以Android为例带大家一起了解Platform Channel的工作原理。

Flutter定义了三种不同类型的Channel，分别是

1.  BasicMessageChannel：用于传递字符串和半结构化的数据;
2.  MethodChannel：用于传递方法调用；
3.  EventChannel：用于数据流的通信；

本文以MethodChannel为例带大家一起进行源码分析。

## MethodChannel源码解析 ##

### 官方架构图 ###

![e951c264925fdfb578b3f9e5cb7be44e.png][]

根据架构图，我们可以看出在Flutter端，MethodChannel允许发送与方法调用相对应的消息。在安卓和iOS原生端，Android上的`MethodChannel`和iOS上的`FlutterMethodChannel`启用接收方法调用并发回结果给Flutter端。而这种数据传递方式还可以反向调用。为了保证用户界面保持相应而不卡顿，消息和响应以异步的形式进行传递。

下面根据官方提供的demo一步一步来进行分析其具体实现。官方提供的demo代码地址如下，实现了一个从Flutter端发起的方法调用，从原生端获取电量并返回给Flutter端用于展示。

[flutter.dev/docs/develo…][flutter.dev_docs_develo]

先来看一下Flutter中dart相关的代码

static const platform = const MethodChannel('samples.flutter.io/battery');
    
    Future<void> _getBatteryLevel() async {
    	String batteryLevel;
    	try {
    	  final int result = await platform.invokeMethod('getBatteryLevel');
    	  batteryLevel = 'Battery level at $result % .';
    	} on PlatformException catch (e) {
    	  batteryLevel = "Failed to get battery level: '${e.message}'.";
    	}
    	...
    }
    复制代码

### Dart层方法调用的消息传递分析 ###

首先，dart中会先创建一个`MethodChannel`对象，其名称为“samples.flutter.io/battery”，这个名字很关键，必须与原生端的名字相对应，具体原因后边会有解释。通过异步方式调用`invokeMethod`方法传入方法名来获取电量信息`platform.invokeMethod('getBatteryLevel');`，invokeMethod方法具体实现如下

*  ../engine/shell/platform/android/io/flutter/plugin/common/MethodChannel.java

@optionalTypeArgs
      Future<T> invokeMethod<T>(String method, [dynamic arguments]) async {
        assert(method != null);
        final ByteData result = await BinaryMessages.send(
          name,
          codec.encodeMethodCall(MethodCall(method, arguments)),
        );
        if (result == null) {
          throw MissingPluginException('No implementation found for method $method on channel $name');
        }
        final T typedResult = codec.decodeEnvelope(result);
        return typedResult;
      }
    复制代码

通过`BinaryMessages.send()`方法来发送方法调用消息，我们可以看到send方法有两个参数，第一个是channel的名称，第二个是`ByteData`对象（使用codec对根据方法名和参数构建的`MethodCall`对象进行编码得到的对象）；codec对象是在`MethodChannel`对象创建时默认创建的`StandardMethodCodec`对象，其对`MethodCall`对象的编码过程如下

*  ../engine/shell/platform/android/io/flutter/plugin/common/StandardMethodCodec.java

@override
    ByteData encodeMethodCall(MethodCall call) {
    	final WriteBuffer buffer = WriteBuffer();
    	messageCodec.writeValue(buffer, call.method);
    	messageCodec.writeValue(buffer, call.arguments);
    	return buffer.done();
    }
    复制代码

通过messageCodec将调用的方法名和传递的参数写入到buffer中，messageCodec是一个`StandardMessageCodec`对象，在`StandardMethodCodec`对象创建时默认创建，其writeValue方法的实现如下

*  ../engine/shell/platform/android/io/flutter/plugin/common/StandardMessageCodec.java

void writeValue(WriteBuffer buffer, dynamic value) {
        if (value == null) {
          buffer.putUint8(_valueNull);
        } else if (value is bool) {
          buffer.putUint8(value ? _valueTrue : _valueFalse);
        } else if (value is int) {
          if (-0x7fffffff - 1 <= value && value <= 0x7fffffff) {
            buffer.putUint8(_valueInt32);
            buffer.putInt32(value);
          } else {
            buffer.putUint8(_valueInt64);
            buffer.putInt64(value);
          }
        } else if (value is double) {
          buffer.putUint8(_valueFloat64);
          buffer.putFloat64(value);
        } else if (value is String) {
          buffer.putUint8(_valueString);
          final List<int> bytes = utf8.encoder.convert(value);
          writeSize(buffer, bytes.length);
          buffer.putUint8List(bytes);
        } else if (value is Uint8List) {
          buffer.putUint8(_valueUint8List);
          writeSize(buffer, value.length);
          buffer.putUint8List(value);
        } else if (value is Int32List) {
          buffer.putUint8(_valueInt32List);
          writeSize(buffer, value.length);
          buffer.putInt32List(value);
        } else if (value is Int64List) {
          buffer.putUint8(_valueInt64List);
          writeSize(buffer, value.length);
          buffer.putInt64List(value);
        } else if (value is Float64List) {
          buffer.putUint8(_valueFloat64List);
          writeSize(buffer, value.length);
          buffer.putFloat64List(value);
        } else if (value is List) {
          buffer.putUint8(_valueList);
          writeSize(buffer, value.length);
          for (final dynamic item in value) {
            writeValue(buffer, item);
          }
        } else if (value is Map) {
          buffer.putUint8(_valueMap);
          writeSize(buffer, value.length);
          value.forEach((dynamic key, dynamic value) {
            writeValue(buffer, key);
            writeValue(buffer, value);
          });
        } else {
          throw ArgumentError.value(value);
        }
      }
    复制代码

从上述代码看出，Flutter与平台端的消息传递支持12种类型，这12种类型分别与安卓和iOS中的类型相对应，看下面表格更直观

<table> 
 <thead> 
  <tr> 
   <th>Dart</th> 
   <th>Android</th> 
   <th>iOS</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>null</td> 
   <td>null</td> 
   <td>nil (NSNull when nested)</td> 
  </tr> 
  <tr> 
   <td>bool</td> 
   <td>java.lang.Boolean</td> 
   <td>NSNumber numberWithBool:</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>java.lang.Integer</td> 
   <td>NSNumber numberWithInt:</td> 
  </tr> 
  <tr> 
   <td>int, if 32 bits not enough</td> 
   <td>java.lang.Long</td> 
   <td>NSNumber numberWithLong:</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>java.lang.Double</td> 
   <td>NSNumber numberWithDouble:</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>java.lang.String</td> 
   <td>NSString</td> 
  </tr> 
  <tr> 
   <td>Uint8List</td> 
   <td>byte[]</td> 
   <td>FlutterStandardTypedData typedDataWithBytes:</td> 
  </tr> 
  <tr> 
   <td>Int32List</td> 
   <td>int[]</td> 
   <td>FlutterStandardTypedData typedDataWithInt32:</td> 
  </tr> 
  <tr> 
   <td>Int64List</td> 
   <td>long[]</td> 
   <td>FlutterStandardTypedData typedDataWithInt64:</td> 
  </tr> 
  <tr> 
   <td>Float64List</td> 
   <td>double[]</td> 
   <td>FlutterStandardTypedData typedDataWithFloat64:</td> 
  </tr> 
  <tr> 
   <td>List</td> 
   <td>java.util.ArrayList</td> 
   <td>NSArray</td> 
  </tr> 
  <tr> 
   <td>Map</td> 
   <td>java.util.HashMap</td> 
   <td>NSDictionary</td> 
  </tr> 
 </tbody> 
</table>

`writeValue`方法其实就是将方法名和参数转化为对应的二进制数据写入buffer中，方法名都是String类型，我们就以String类型方法写入过程来进行简单说明，如果判断一个value为String后，

1.  调用`buffer.putUint8(_valueString);`先写入对应的类型值，`_valueString = 7;`，所以将`00000111`二进制数据写入buffer；
2.  紧接着将value通过utf8编码为int数组，然后将数组的长度数据通过`writeSize(buffer, bytes.length);`写入buffer；
3.  最后再将数组数据写入buffer，至此一个方法名编码完成；

其他类型的数据依次类推进行编码，编码完成后，将`StandardMessageCodec`对象编码的ByteData数据通过`BinaryMessages.send()`方法发送出去，看下send方法的具体实现

*  ../flutter/packages/flutter/lib/src/services/platform\_messages.dart

static Future<ByteData> send(String channel, ByteData message) {
    	final _MessageHandler handler = _mockHandlers[channel];
    	if (handler != null)
    	  return handler(message);
    	return _sendPlatformMessage(channel, message);
    }
    复制代码

会从`_mockHandlers`中查找是否缓存的有`_MessageHandler`对象，如果没有则通过`_sendPlatformMessage`方法发送消息，

*  ../flutter/packages/flutter/lib/src/services/platform\_messages.dart

static Future<ByteData> _sendPlatformMessage(String channel, ByteData message) {
        final Completer<ByteData> completer = Completer<ByteData>();
        ui.window.sendPlatformMessage(channel, message, (ByteData reply) {
          try {
            completer.complete(reply);
          } catch (exception, stack) {
            FlutterError.reportError(FlutterErrorDetails(
              exception: exception,
              stack: stack,
              library: 'services library',
              context: 'during a platform message response callback',
            ));
          }
        });
        return completer.future;
      }
    复制代码

其最终调用的是`ui.window.sendPlatformMessage`方法，该方法中会传递回调方法对象，在数据返回后会被回调从而得到结果数据。

*  ../engine/lib/ui/window.dart

void sendPlatformMessage(String name,
                               ByteData data,
                               PlatformMessageResponseCallback callback) {
        final String error =
            _sendPlatformMessage(name, _zonedPlatformMessageResponseCallback(callback), data);
        if (error != null)
          throw new Exception(error);
      }
      String _sendPlatformMessage(String name,
                                  PlatformMessageResponseCallback callback,
                                  ByteData data) native 'Window_sendPlatformMessage';
    复制代码

在以上代码中`ui.window.sendPlatformMessage()`方法最终会调用Dart本地接口方法`_sendPlatformMessage`，这里可以将这个方法简单理解为类似于java的JNI的方法，在c++层会调用"Window\_sendPlatformMessage"对应的方法。至此，dart中的方法消息传递已经结束，我们下面开始从Flutter engine源码中分析c++层是如何对方法调用消息进行传递的。

### c++层消息的传递流程分析 ###

我们在engine源码文件的./lib/ui/window/window.cc文件中找到了关于dart本地方法的注册代码块

*  ../engine/lib/ui/window/window.cc

void Window::RegisterNatives(tonic::DartLibraryNatives* natives) {
      natives->Register({
          {"Window_defaultRouteName", DefaultRouteName, 1, true},
          {"Window_scheduleFrame", ScheduleFrame, 1, true},
          {"Window_sendPlatformMessage", _SendPlatformMessage, 4, true},
          {"Window_respondToPlatformMessage", _RespondToPlatformMessage, 3, true},
          {"Window_render", Render, 2, true},
          {"Window_updateSemantics", UpdateSemantics, 2, true},
          {"Window_setIsolateDebugName", SetIsolateDebugName, 2, true},
      });
    }
    复制代码

通过代码可以看到通过`tonic::DartLibraryNatives`的对象指针调用`Register()`方法对window对应的多个dart本地方法进行了注册（说明：该注册方法的调用是在flutter引擎初始化后Dart虚拟机初始化时调用，这里不再对这一块进行分析，知道即可）。其中就有上面提到的“Window\_sendPlatformMessage”，该符号对应到的c++方法为`_SendPlatformMessage`，我们看下该方法中做了些什么，

*  ../engine/lib/ui/window/window.cc

void _SendPlatformMessage(Dart_NativeArguments args) {
      tonic::DartCallStatic(&SendPlatformMessage, args);
    }
    
    Dart_Handle SendPlatformMessage(Dart_Handle window,
                                    const std::string& name,
                                    Dart_Handle callback,
                                    const tonic::DartByteData& data) {
      UIDartState* dart_state = UIDartState::Current();
    
      ...
    
      fml::RefPtr<PlatformMessageResponse> response;
      if (!Dart_IsNull(callback)) {
        response = fml::MakeRefCounted<PlatformMessageResponseDart>(
            tonic::DartPersistentValue(dart_state, callback),
            dart_state->GetTaskRunners().GetUITaskRunner());
      }
      if (Dart_IsNull(data.dart_handle())) {
        dart_state->window()->client()->HandlePlatformMessage(
            fml::MakeRefCounted<PlatformMessage>(name, response));
      } else {
        const uint8_t* buffer = static_cast<const uint8_t*>(data.data());
    
    	// data数据部位null，会走下面这块代码
        dart_state->window()->client()->HandlePlatformMessage(
            fml::MakeRefCounted<PlatformMessage>(
                name, std::vector<uint8_t>(buffer, buffer + data.length_in_bytes()),
                response));
      }
    
      return Dart_Null();
    }
    复制代码

dart\_state是一个`UIDartState`对象指针，指向当前线程（UI thread）对应的isolate对象Root isolate，回调对象callback不为null，则会根据`dart_state`和`callback`创建一个`tonic::DartPersistentValue`对象，然后根据当前线程的ui task runner创建一个平台消息响应对象`response`(该`response`会在消息响应结果返回时使用到)，接下来走到代码中注释下面的代码块，其`dart_state->window()->client()`返回的是`Engine`对象创建时创建的`RuntimeController`对象(这个也要回溯到引擎和DartVM初始化的过程，这里不再展开，知道即可)，下面会调用该对象的`HandlePlatformMessage()`方法，方法中传递的是包含有channel名、方法调用的相关数据和response对象(fml::RefPtr对象，消息响应返回后会使用到)的`fml::RefPtr<PlatformMessage>`对象。

*  ../engine/runtime/runtime\_controller.cc

void RuntimeController::HandlePlatformMessage(
        fml::RefPtr<PlatformMessage> message) {
      client_.HandlePlatformMessage(std::move(message));
    }
    复制代码

接着调用`client_`的`HandlePlatformMessage()`方法，`client_`是一个继承了`RuntimeDelegate`类的`Engine`对象，

*  ../engine/shell/common/engine.cc

void Engine::HandlePlatformMessage(
        fml::RefPtr<blink::PlatformMessage> message) {
      if (message->channel() == kAssetChannel) {
        HandleAssetPlatformMessage(std::move(message));
      } else {
        delegate_.OnEngineHandlePlatformMessage(std::move(message));
      }
    }
    复制代码

由最开始的demo可知channel是我们自定义的名称为“samples.flutter.io/battery”的channel，所以会执行`else`中的代码块，这里的`delegate_`是指继承了`Engine::Delegate`类的`Shell`对象，

*  ../engine/shell/common/shell.cc

// |shell::Engine::Delegate|
    void Shell::OnEngineHandlePlatformMessage(
        fml::RefPtr<blink::PlatformMessage> message) {
        
      ...
      task_runners_.GetPlatformTaskRunner()->PostTask(
          [view = platform_view_->GetWeakPtr(), message = std::move(message)]() {
            if (view) {
              view->HandlePlatformMessage(std::move(message));
            }
          });
    }
    复制代码

由于Engine的创建是在UI task Runner中即UI thread中创建，所以以上所有消息传递都是在UI thread中进行，由于平台相关的api都是运行在主线程，马上要将消息发送给平台，所以此处会将消息交由platform task Runner执行，即在platform thread中执行方法调用。`platform_view_`是一个继承了`PlatformView`类的`PlatformViewAndroid`对象，该对象在创建`AndroidShellHolder`对象时被创建。`view->HandlePlatformMessage`执行以下方法，

*  ../engine/shell/platform/android/platform\_view\_android.cc

// |shell::PlatformView|
    void PlatformViewAndroid::HandlePlatformMessage(
        fml::RefPtr<blink::PlatformMessage> message) {
      JNIEnv* env = fml::jni::AttachCurrentThread();
      fml::jni::ScopedJavaLocalRef<jobject> view = java_object_.get(env);
      if (view.is_null())
        return;
    
      int response_id = 0;
      if (auto response = message->response()) {
        response_id = next_response_id_++;
        pending_responses_[response_id] = response;
      }
      auto java_channel = fml::jni::StringToJavaString(env, message->channel());
      if (message->hasData()) {
        fml::jni::ScopedJavaLocalRef<jbyteArray> message_array(
            env, env->NewByteArray(message->data().size()));
        env->SetByteArrayRegion(
            message_array.obj(), 0, message->data().size(),
            reinterpret_cast<const jbyte*>(message->data().data()));
        message = nullptr;
    
        // This call can re-enter in InvokePlatformMessageXxxResponseCallback.
        FlutterViewHandlePlatformMessage(env, view.obj(), java_channel.obj(),
                                         message_array.obj(), response_id);
      } else {
        ...
      }
    }
    复制代码

消息响应对象`response`不为空时，创建一个`response_id`并将其对应`response`保存到`pending_responses_`中（消息响应结果返回后会根据`response_id`取出`response`对象来处理响应结果），消息数据不为空时调用if代码块中的代码，然后会调用`platform_view_android_jni.cc`中的以下方法，`view.obj()`为java中的flutterJNI对象，这个对象是在`AndroidShellHolder`对象创建时从java层传递过来的。最后通过`env->CallVoidMethod()`方法调用java层的`flutterJNI`对象的`handlePlatformMessage`方法，将channel名称、消息内容和响应ID传给java层。

*  ../engine/shell/platform/android/platform\_view\_android\_jni.cc

static jmethodID g_handle_platform_message_method = nullptr;
    void FlutterViewHandlePlatformMessage(JNIEnv* env,
                                          jobject obj,
                                          jstring channel,
                                          jobject message,
                                          jint responseId) {
      env->CallVoidMethod(obj, g_handle_platform_message_method, channel, message,
                          responseId);
      FML_CHECK(CheckException(env));
    }
    复制代码

接下来我们开始分析java层接收到消息后的处理逻辑。

### java层接受消息后的处理流程分析 ###

通过以上分析，c++层通过调用flutterJNI的`handlePlatformMessage`方法将消息传递给java层，我们来看一下FlutterJNI中的方法实现

*  ../engine/shell/platform/android/io/flutter/embedding/engine/FlutterJNI.java

private void handlePlatformMessage(String channel, byte[] message, int replyId) {
        if (this.platformMessageHandler != null) {
            this.platformMessageHandler.handleMessageFromDart(channel, message, replyId);
        }
    }
    复制代码

此时会调用`platformMessageHandler`的`handleMessageFromDart()`方法，`platformMessageHandler`对象是在`FlutterNativeView`构造方法中创建`FlutterJNI`对象后设置进来的，是一个实现了`PlatformMessageHandler`接口的`FlutterNativeView.PlatformMessageHandlerImpl`对象，我们看一下它的`handleMessageFromDart()`方法实现，（最新版本的engine源码中将处理dart消息的代码提到了`DartMessager`类中，请大家注意。）

../engine/shell/platform/android/io/flutter/view/FlutterNativeView.java

public void handleMessageFromDart(final String channel, byte[] message, final int replyId) {
        FlutterNativeView.this.assertAttached();
        BinaryMessageHandler handler = (BinaryMessageHandler)FlutterNativeView.this.mMessageHandlers.get(channel);
        if (handler != null) {
            try {
                ByteBuffer buffer = message == null ? null : ByteBuffer.wrap(message);
                handler.onMessage(buffer, new BinaryReply() {
                    private final AtomicBoolean done = new AtomicBoolean(false);
    
                    public void reply(ByteBuffer reply) {
                        if (!FlutterNativeView.this.isAttached()) {
                            Log.d("FlutterNativeView", "handleMessageFromDart replying ot a detached view, channel=" + channel);
                        } else if (this.done.getAndSet(true)) {
                            throw new IllegalStateException("Reply already submitted");
                        } else {
                            if (reply == null) {
                                FlutterNativeView.this.mFlutterJNI.invokePlatformMessageEmptyResponseCallback(replyId);
                            } else {
                                FlutterNativeView.this.mFlutterJNI.invokePlatformMessageResponseCallback(replyId, reply, reply.position());
                            }
    
                        }
                    }
                });
            } catch (Exception var6) {
                Log.e("FlutterNativeView", "Uncaught exception in binary message listener", var6);
                FlutterNativeView.this.mFlutterJNI.invokePlatformMessageEmptyResponseCallback(replyId);
            }
    
        } else {
            FlutterNativeView.this.mFlutterJNI.invokePlatformMessageEmptyResponseCallback(replyId);
        }
    }
    复制代码

首先根据channel名称从`mMessageHandlers`中查找对应的`BinaryMessageHandler`对象，如果找到则执行该对象的`onMessage()`方法，那么`mMessageHandlers`中是怎么保存我们的channel名称为“samples.flutter.io/battery”的对象的呢，我们看下开始所说的demo中的java模块相关代码，

private static final String CHANNEL = "samples.flutter.io/battery";
    
    new MethodChannel(getFlutterView(), CHANNEL).setMethodCallHandler(
            new MethodChannel.MethodCallHandler() {
              @Override
              public void onMethodCall(MethodCall call, MethodChannel.Result result) {
                if (call.method.equals("getBatteryLevel")) {
                  int batteryLevel = getBatteryLevel();
    
                  if (batteryLevel != -1) {
                    result.success(batteryLevel);
                  } else {
                    result.error("UNAVAILABLE", "Battery level not available.", null);
                  }
                } else {
                  result.notImplemented();
                }
              }
            });
    复制代码

这块代码在`MainActivity`中的`onCreate`方法中，创建一个名为“samples.flutter.io/battery”的`MethodChannel`对象，然后设置对应的`MethodCallHandler`对象，`setMethodCallHandler`的方法实现如下

*  ../engine/shell/platform/android/io/flutter/plugin/common/MethodChannel.java

public void setMethodCallHandler(@Nullable MethodChannel.MethodCallHandler handler) {
        this.messenger.setMessageHandler(this.name, handler == null ? null : new MethodChannel.IncomingMethodCallHandler(handler));
    }
    复制代码

其中的`messenger`就是通过`getFlutterView()`获取到的实现了`BinaryMessenger`接口的`FlutterView`对象，方法的第二个参数是通过`handler`对象包装的`MethodChannel.IncomingMethodCallHandler`对象，看下`FlutterView`中对接口方法`setMessageHandler()`的实现

*  ../engine/shell/platform/android/io/flutter/view/FlutterView.java

public void setMessageHandler(String channel, BinaryMessageHandler handler) {
        this.mNativeView.setMessageHandler(channel, handler);
    }
    复制代码

会调用对应的`FlutterNativeView`的`setMessageHandler()`方法，`FlutterNativeView`同样实现了`BinaryMessenger`接口，看下其中的方法实现

*  ../engine/shell/platform/android/io/flutter/view/FlutterNativeView.java

public void setMessageHandler(String channel, BinaryMessageHandler handler) {
        if (handler == null) {
            this.mMessageHandlers.remove(channel);
        } else {
            this.mMessageHandlers.put(channel, handler);
        }
    }
    复制代码

到此，我们发现在`MainActivity`的`onCreate`方法中实现的`MethodCallHandler`通过一系列操作被包装到`IncomingMethodCallHandler`对象中并设置进了`mMessageHandlers`中。那么我们上面所说的`onMessage`方法的调用即是`IncomingMethodCallHandler`对象的方法，

*  ../engine/shell/platform/android/io/flutter/plugin/common/MethodChannel.java

public void onMessage(ByteBuffer message, final BinaryReply reply) {
        MethodCall call = MethodChannel.this.codec.decodeMethodCall(message);
    
        try {
            this.handler.onMethodCall(call, new MethodChannel.Result() {
                public void success(Object result) {
                    reply.reply(MethodChannel.this.codec.encodeSuccessEnvelope(result));
                }
    
                public void error(String errorCode, String errorMessage, Object errorDetails) {
                    reply.reply(MethodChannel.this.codec.encodeErrorEnvelope(errorCode, errorMessage, errorDetails));
                }
    
                public void notImplemented() {
                    reply.reply((ByteBuffer)null);
                }
            });
        } catch (RuntimeException var5) {
            Log.e("MethodChannel#" + MethodChannel.this.name, "Failed to handle method call", var5);
            reply.reply(MethodChannel.this.codec.encodeErrorEnvelope("error", var5.getMessage(), (Object)null));
        }
    
    }
    复制代码

方法中首先将从c++层传递过来的消息通过`codec`解码为`MethodCall`对象，然后调用`MainActivity`中实现的`MethodHandler`的`onMethodCall`方法，改方法实现中会获取当前手机电量信息`int batteryLevel = getBatteryLevel();`，然后调用`result.success()`方法，通过`reply.reply(MethodChannel.this.codec.encodeSuccessEnvelope(result));`将结果数据编码后进行返回。reply方法中会调用`FlutterNativeView.this.mFlutterJNI.invokePlatformMessageResponseCallback(replyId, reply, reply.position());`方法将响应结果返回，方法具体实现如下

*  ../engine/shell/platform/android/io/flutter/embedding/engine/FlutterJNI.java

@UiThread
    public void invokePlatformMessageResponseCallback(int responseId, ByteBuffer message, int position) {
        this.ensureAttachedToNative();
        this.nativeInvokePlatformMessageResponseCallback(this.nativePlatformViewId, responseId, message, position);
    }
        
    private native void nativeInvokePlatformMessageResponseCallback(long var1, int var3, ByteBuffer var4, int var5);
    复制代码

最终会调用JNI方法将数据返回给c++层，下面我们再接着看c++层中接受到响应数据后的处理逻辑。

### c++层接收消息响应后的处理流程分析 ###

根据JNI方法动态注册模块可知，`nativeInvokePlatformMessageResponseCallback`方法对应以下c++方法，

*  ../engine/shell/platform/android/platform\_view\_android\_jni.cc

static void InvokePlatformMessageResponseCallback(JNIEnv* env,
                                                      jobject jcaller,
                                                      jlong shell_holder,
                                                      jint responseId,
                                                      jobject message,
                                                      jint position) {
      ANDROID_SHELL_HOLDER->GetPlatformView()
          ->InvokePlatformMessageResponseCallback(env,         //
                                                  responseId,  //
                                                  message,     //
                                                  position     //
          );
    }
    复制代码

接着会调用`AndroidShellHolder`对象持有的`PlatformViewAndroid`对象的`InvokePlatformMessageResponseCallback`方法，

*  ../engine/shell/platform/android/platform\_view\_android.cc

void PlatformViewAndroid::InvokePlatformMessageResponseCallback(
        JNIEnv* env,
        jint response_id,
        jobject java_response_data,
        jint java_response_position) {
      if (!response_id)
        return;
      auto it = pending_responses_.find(response_id);
      if (it == pending_responses_.end())
        return;
      uint8_t* response_data =
          static_cast<uint8_t*>(env->GetDirectBufferAddress(java_response_data));
      std::vector<uint8_t> response = std::vector<uint8_t>(
          response_data, response_data + java_response_position);
      auto message_response = std::move(it->second);
      pending_responses_.erase(it);
      message_response->Complete(
          std::make_unique<fml::DataMapping>(std::move(response)));
    }
    复制代码

根据`response_id`从`pending_responses_`中查找对应的`message_response`对象，通过对象指针调用其`Complete`方法处理响应结果，根据以上过程中代码的分析可知该方法对应的是继承了`PlatformMessageResponse`类的`PlatformMessageResponseDart`类对象的`Complete`方法，

*  ../engine/lib/ui/window/platform\_message\_response\_dart.cc

void PlatformMessageResponseDart::Complete(std::unique_ptr<fml::Mapping> data) {
      if (callback_.is_empty())
        return;
      FML_DCHECK(!is_complete_);
      is_complete_ = true;
      ui_task_runner_->PostTask(fml::MakeCopyable(
          [callback = std::move(callback_), data = std::move(data)]() mutable {
            std::shared_ptr<tonic::DartState> dart_state =
                callback.dart_state().lock();
            if (!dart_state)
              return;
            tonic::DartState::Scope scope(dart_state);
    
            Dart_Handle byte_buffer = WrapByteData(std::move(data));
            tonic::DartInvoke(callback.Release(), {byte_buffer});
          }));
    }
    复制代码

这里会将返回的数据处理通过ui\_task\_runner执行，即会在UI thread中执行。callback即为上面分析的dart中对应的回调方法`PlatformMessageResponseCallback`的对象，通过`tonic::DartInvoke()`方法将消息返回结果传递到dart层进行处理。

### Dart层接收消息响应后的处理流程分析 ###

通过以上Dart层传递消息分析可知`PlatformMessageResponseCallback`方法回调后对byte\_buffer数据进行处理，通过completer.complete()方法完成返回数据，然后一步步返回到调用方法层，在异步方法中通过await等待数据返回后，再通过setState改变State中的变量值从而刷新页面数据将电量信息显示到屏幕上。至此，整个flutter发消息给platform并接收消息处理的流程就完成了。

## 总结 ##

先上一张消息传递流程图

![532728236103c37f52d06e76376249dd.png][]

通过整个源码流程的跟踪，整个消息发送和接收结果的流程分为以下几步：

1.  Dart层通过以上提到的12种类型包含的类型数据进行编码，然后通过dart的类似jni的本地接口方法传递给c++层；
2.  c++层通过持有java对象`flutterJNI`的方法调用将消息传递到java层；
3.  java层解码接收到的消息，根据消息内容做指定的逻辑处理，得到结果后进行编码通过jni方法将响应结果返回给c++层；
4.  c++层处理返回的响应结果，并将结果通过发送时保存的dart响应方法对象回调给Dart层；
5.  Dart层通过回调方法对结果数据进行处理，然后通过codec解码数据做后续的操作；

说明：

文章转载自对应的“Flutter编程指南”微信公众号，更多Flutter相关技术文章打开微信扫描二维码关注微信公众号获取。

作者：Flutter编程指南  
链接：https://juejin.cn/post/6844903805285318670  
来源：掘金  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

[e951c264925fdfb578b3f9e5cb7be44e.png]: /images/20221120/689dac048a9a4f2ebb761cc20229fccb.png
[flutter.dev_docs_develo]: https://flutter.dev/docs/development/platform-integration/platform-channels
[532728236103c37f52d06e76376249dd.png]: /images/20221120/9d98be4d61b643018f922d7387e28dd0.png