io.flutter.embedding.engine.dart.DartMessenger Class Reference

Inheritance diagram for io.flutter.embedding.engine.dart.DartMessenger:

Classes
class	ConcurrentTaskQueue
interface	DartMessengerTaskQueue
class	Reply
class	SerialTaskQueue
interface	TaskQueueFactory

Public Member Functions
TaskQueue	makeBackgroundTaskQueue (TaskQueueOptions options)
void	setMessageHandler ( @NonNull String channel, @Nullable BinaryMessenger.BinaryMessageHandler handler)
void	setMessageHandler ( @NonNull String channel, @Nullable BinaryMessenger.BinaryMessageHandler handler, @Nullable TaskQueue taskQueue)
void	enableBufferingIncomingMessages ()
void	disableBufferingIncomingMessages ()
void	send (@NonNull String channel, @NonNull ByteBuffer message)
void	send ( @NonNull String channel, @Nullable ByteBuffer message, @Nullable BinaryMessenger.BinaryReply callback)
void	handleMessageFromDart ( @NonNull String channel, @Nullable ByteBuffer message, int replyId, long messageData)
void	handlePlatformMessageResponse (int replyId, @Nullable ByteBuffer reply)
int	getPendingChannelResponseCount ()

Package Functions
	DartMessenger (@NonNull FlutterJNI flutterJNI, @NonNull TaskQueueFactory taskQueueFactory)
	DartMessenger (@NonNull FlutterJNI flutterJNI)

Detailed Description

Message conduit for 2-way communication between Android and Dart.

See BinaryMessenger, which sends messages from Android to Dart

See PlatformMessageHandler, which handles messages to Android from Dart

Definition at line 32 of file DartMessenger.java.

Constructor & Destructor Documentation

DartMessenger() [1/2]

io.flutter.embedding.engine.dart.DartMessenger.DartMessenger ( @NonNull FlutterJNI  flutterJNI, @NonNull TaskQueueFactory  taskQueueFactory  )

inlinepackage

Definition at line 66 of file DartMessenger.java.

                                                                                            {
    this.flutterJNI = flutterJNI;
    this.taskQueueFactory = taskQueueFactory;
  }

DartMessenger() [2/2]

io.flutter.embedding.engine.dart.DartMessenger.DartMessenger ( @NonNull FlutterJNI  flutterJNI )

inlinepackage

Definition at line 71 of file DartMessenger.java.

                                                {
    this(flutterJNI, new DefaultTaskQueueFactory());
  }

Member Function Documentation

disableBufferingIncomingMessages()

void io.flutter.embedding.engine.dart.DartMessenger.disableBufferingIncomingMessages ( )

inline

Definition at line 245 of file DartMessenger.java.

                                                 {
    Map<String, List<BufferedMessageInfo>> pendingMessages;
    synchronized (handlersLock) {
      enableBufferingIncomingMessages.set(false);
      pendingMessages = bufferedMessages;
      bufferedMessages = new HashMap<>();
    }
    for (Map.Entry<String, List<BufferedMessageInfo>> channel : pendingMessages.entrySet()) {
      for (BufferedMessageInfo info : channel.getValue()) {
        dispatchMessageToQueue(
            channel.getKey(), null, info.message, info.replyId, info.messageData);
      }
    }
  }

enableBufferingIncomingMessages()

void io.flutter.embedding.engine.dart.DartMessenger.enableBufferingIncomingMessages ( )

inline

Definition at line 240 of file DartMessenger.java.

                                                {
    enableBufferingIncomingMessages.set(true);
  }

getPendingChannelResponseCount()

int io.flutter.embedding.engine.dart.DartMessenger.getPendingChannelResponseCount ( )

inline

Returns the number of pending channel callback replies.

When sending messages to the Flutter application using ByteBuffer, io.flutter.plugin.common.BinaryMessenger.BinaryReply), developers can optionally specify a reply callback if they expect a reply from the Flutter application.

This method tracks all the pending callbacks that are waiting for response, and is supposed to be called from the main thread (as other methods). Calling from a different thread could possibly capture an indeterministic internal state, so don't do it.

Definition at line 402 of file DartMessenger.java.

                                              {
    return pendingReplies.size();
  }

handleMessageFromDart()

void io.flutter.embedding.engine.dart.DartMessenger.handleMessageFromDart ( @NonNull String  channel, @Nullable ByteBuffer  message, int  replyId, long  messageData  )

inline

Called from any thread.

Implements io.flutter.embedding.engine.dart.PlatformMessageHandler.

Definition at line 336 of file DartMessenger.java.

                                                                                            {
    // Called from any thread.
    Log.v(TAG, "Received message from Dart over channel '" + channel + "'");
 
    HandlerInfo handlerInfo;
    boolean messageDeferred;
    // This lock can potentially be a bottleneck and could replaced with a
    // read/write lock.
    synchronized (handlersLock) {
      handlerInfo = messageHandlers.get(channel);
      messageDeferred = (enableBufferingIncomingMessages.get() && handlerInfo == null);
      if (messageDeferred) {
        // The channel is not defined when the Dart VM sends a message before the channels are
        // registered.
        //
        // This is possible if the Dart VM starts before channel registration, and if the thread
        // that registers the channels is busy or slow at registering the channel handlers.
        //
        // In such cases, the task dispatchers are queued, and processed when the channel is
        // defined.
        if (!bufferedMessages.containsKey(channel)) {
          bufferedMessages.put(channel, new LinkedList<>());
        }
        List<BufferedMessageInfo> buffer = bufferedMessages.get(channel);
        buffer.add(new BufferedMessageInfo(message, replyId, messageData));
      }
    }
    if (!messageDeferred) {
      dispatchMessageToQueue(channel, handlerInfo, message, replyId, messageData);
    }
  }

handlePlatformMessageResponse()

void io.flutter.embedding.engine.dart.DartMessenger.handlePlatformMessageResponse ( int  replyId, @Nullable ByteBuffer  reply  )

inline

Implements io.flutter.embedding.engine.dart.PlatformMessageHandler.

Definition at line 370 of file DartMessenger.java.

                                                                                     {
    Log.v(TAG, "Received message reply from Dart.");
    BinaryMessenger.BinaryReply callback = pendingReplies.remove(replyId);
    if (callback != null) {
      try {
        Log.v(TAG, "Invoking registered callback for reply from Dart.");
        callback.reply(reply);
        if (reply != null && reply.isDirect()) {
          // This ensures that if a user retains an instance to the ByteBuffer and it happens to
          // be direct they will get a deterministic error.
          reply.limit(0);
        }
      } catch (Exception ex) {
        Log.e(TAG, "Uncaught exception in binary message reply handler", ex);
      } catch (Error err) {
        handleError(err);
      }
    }
  }

makeBackgroundTaskQueue()

TaskQueue io.flutter.embedding.engine.dart.DartMessenger.makeBackgroundTaskQueue ( TaskQueueOptions  options )

inline

Definition at line 190 of file DartMessenger.java.

                                                                     {
    DartMessengerTaskQueue taskQueue = taskQueueFactory.makeBackgroundTaskQueue(options);
    TaskQueueToken token = new TaskQueueToken();
    createdTaskQueues.put(token, taskQueue);
    return token;
  }

send() [1/2]

void io.flutter.embedding.engine.dart.DartMessenger.send ( @NonNull String  channel, @Nullable ByteBuffer  message, @Nullable BinaryMessenger.BinaryReply  callback  )

inline

Definition at line 268 of file DartMessenger.java.

                                                      {
    try (TraceSection e = TraceSection.scoped("DartMessenger#send on " + channel)) {
      Log.v(TAG, "Sending message with callback over channel '" + channel + "'");
      int replyId = nextReplyId++;
      if (callback != null) {
        pendingReplies.put(replyId, callback);
      }
      if (message == null) {
        flutterJNI.dispatchEmptyPlatformMessage(channel, replyId);
      } else {
        flutterJNI.dispatchPlatformMessage(channel, message, message.position(), replyId);
      }
    }
  }

send() [2/2]

void io.flutter.embedding.engine.dart.DartMessenger.send ( @NonNull String  channel, @NonNull ByteBuffer  message  )

inline

Definition at line 262 of file DartMessenger.java.

                                                                         {
    Log.v(TAG, "Sending message over channel '" + channel + "'");
    send(channel, message, null);
  }

setMessageHandler() [1/2]

void io.flutter.embedding.engine.dart.DartMessenger.setMessageHandler ( @NonNull String  channel, @Nullable BinaryMessenger.BinaryMessageHandler  handler  )

inline

Definition at line 198 of file DartMessenger.java.

                                                                                       {
    setMessageHandler(channel, handler, null);
  }

setMessageHandler() [2/2]

void io.flutter.embedding.engine.dart.DartMessenger.setMessageHandler ( @NonNull String  channel, @Nullable BinaryMessenger.BinaryMessageHandler  handler, @Nullable TaskQueue  taskQueue  )

inline

Definition at line 204 of file DartMessenger.java.

                                     {
    if (handler == null) {
      Log.v(TAG, "Removing handler for channel '" + channel + "'");
      synchronized (handlersLock) {
        messageHandlers.remove(channel);
      }
      return;
    }
    DartMessengerTaskQueue dartMessengerTaskQueue = null;
    if (taskQueue != null) {
      dartMessengerTaskQueue = createdTaskQueues.get(taskQueue);
      if (dartMessengerTaskQueue == null) {
        throw new IllegalArgumentException(
            "Unrecognized TaskQueue, use BinaryMessenger to create your TaskQueue (ex makeBackgroundTaskQueue).");
      }
    }
    Log.v(TAG, "Setting handler for channel '" + channel + "'");
 
    List<BufferedMessageInfo> list;
    synchronized (handlersLock) {
      messageHandlers.put(channel, new HandlerInfo(handler, dartMessengerTaskQueue));
      list = bufferedMessages.remove(channel);
      if (list == null) {
        return;
      }
    }
    for (BufferedMessageInfo info : list) {
      dispatchMessageToQueue(
          channel, messageHandlers.get(channel), info.message, info.replyId, info.messageData);
    }
  }

---

The documentation for this class was generated from the following file:

• shell/platform/android/io/flutter/embedding/engine/dart/DartMessenger.java