最右JS2Flutter框架——通信机制

Map<int, Completer> _completerMap = new Map();

Future<T> callFlutterWithReply<T>(String method, { dynamic key, String action, dynamic data }) async {
  int callbackId = generateGlobalId();
  invokeFlutter(method, _buildBody(key, action, data, callbackId));
  Completer completer = Completer<dynamic>();
  _completerMap[callbackId] = completer;
  T typedResult = await completer.future;
  return typedResult;
}

//当收到Native回调
...
    Completer completer = _completerMap[callbackId];
    if(completer != null) {
      completer.complete(data);
      _completerMap.remove(callbackId);
    }
...

// |PlatformView::Delegate|
void Shell::OnPlatformViewDispatchPlatformMessage(
    fml::RefPtr<PlatformMessage> message) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());

  task_runners_.GetUITaskRunner()->PostTask(
      [engine = engine_->GetWeakPtr(), message = std::move(message)] {
        if (engine) {
          engine->DispatchPlatformMessage(std::move(message));
        }
      });
}

// |PlatformView::Delegate|
void Shell::OnPlatformViewDispatchDirectMessage(
    fml::RefPtr<DirectMessage> message) {
  FML_DCHECK(is_setup_);
  FML_DCHECK(task_runners_.GetUITaskRunner()->RunsTasksOnCurrentThread());

  engine_->DispatchDirectMessage(std::move(message));
}

class _DefaultBinaryMessenger extends BinaryMessenger {
  const _DefaultBinaryMessenger._();

  // Handlers for incoming messages from platform plugins.
  // This is static so that this class can have a const constructor.
  static final Map<String, MessageHandler> _handlers =
      <String, MessageHandler>{};

  static final Map<String, DirectMessageHandler> _directHandlers =
      <String, DirectMessageHandler>{};    

  // Mock handlers that intercept and respond to outgoing messages.
  // This is static so that this class can have a const constructor.
  static final Map<String, MessageHandler> _mockHandlers =
      <String, MessageHandler>{};

  Future<ByteData> _sendPlatformMessage(String channel, ByteData message) {
    final Completer<ByteData> completer = Completer<ByteData>();
    // ui.window is accessed directly instead of using ServicesBinding.instance.window
    // because this method might be invoked before any binding is initialized.
    // This issue was reported in #27541. It is not ideal to statically access
    // ui.window because the Window may be dependency injected elsewhere with
    // a different instance. However, static access at this location seems to be
    // the least bad option.
    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: ErrorDescription('during a platform message response callback'),
        ));
      }
    });
    return completer.future;
  }

  ByteData _sendDirectMessage(String channel, ByteData message) {
    return ui.window.sendDirectMessage(channel, message);
  }


  @override
  Future<void> handlePlatformMessage(
    String channel,
    ByteData data,
    ui.PlatformMessageResponseCallback callback,
  ) async {
    ByteData response;
    try {
      final MessageHandler handler = _handlers[channel];
      if (handler != null) {
        response = await handler(data);
      } else {
        ui.channelBuffers.push(channel, data, callback);
        callback = null;
      }
    } catch (exception, stack) {
      FlutterError.reportError(FlutterErrorDetails(
        exception: exception,
        stack: stack,
        library: 'services library',
        context: ErrorDescription('during a platform message callback'),
      ));
    } finally {
      if (callback != null) {
        callback(response);
      }
    }
  }


  @override
  void handleDirectMessage(
      String channel,
      ByteData data,
      ui.DirectMessageResultCallback callback,
      ) async {
    ByteData result;
    try {
      final DirectMessageHandler handler = _directHandlers[channel];
      if (handler != null)
        result = handler(data);
    } catch (exception, stack) {
      FlutterError.reportError(FlutterErrorDetails(
        exception: exception,
        stack: stack,
        library: 'services library',
        context: ErrorDescription('during a direct message callback'),
      ));
    } finally {
      callback(result);
    }
  }


  @override
  Future<ByteData> send(String channel, ByteData message) {
    final MessageHandler handler = _mockHandlers[channel];
    if (handler != null)
      return handler(message);
    return _sendPlatformMessage(channel, message);
  }

  @override
  ByteData sendDirect(String channel, ByteData message) {
    return _sendDirectMessage(channel, message);
  }

  @override
  void setMessageHandler(String channel, MessageHandler handler) {
    if (handler == null)
      _handlers.remove(channel);
    else
      _handlers[channel] = handler;
    ui.channelBuffers.drain(channel, (ByteData data, ui.PlatformMessageResponseCallback callback) async {
      await handlePlatformMessage(channel, data, callback);
    });
  }

  @override
  void setDirectMessageHandler(String channel, DirectMessageHandler handler) {
    if (handler == null)
      _directHandlers.remove(channel);
    else
      _directHandlers[channel] = handler;
  }

  ...
}