fl_binary_messenger.cc File Reference

#include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h"
#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/fml/logging.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/fl_method_codec_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_engine.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_channel.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_codec.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
#include <gmodule.h>

Go to the source code of this file.

Classes
struct	_FlBinaryMessengerResponseHandleImpl
struct	PlatformMessageHandler

Functions
	G_DEFINE_QUARK (fl_binary_messenger_codec_error_quark, fl_binary_messenger_codec_error) G_DECLARE_FINAL_TYPE(FlBinaryMessengerImpl
GObject	G_DECLARE_FINAL_TYPE (FlBinaryMessengerResponseHandleImpl, fl_binary_messenger_response_handle_impl, FL, BINARY_MESSENGER_RESPONSE_HANDLE_IMPL, FlBinaryMessengerResponseHandle) struct _FlBinaryMessengerImpl
static void	fl_binary_messenger_impl_iface_init (FlBinaryMessengerInterface *iface)
	G_DEFINE_TYPE_WITH_CODE (FlBinaryMessengerImpl, fl_binary_messenger_impl, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(fl_binary_messenger_get_type(), fl_binary_messenger_impl_iface_init)) static void fl_binary_messenger_response_handle_class_init(FlBinaryMessengerResponseHandleClass *klass)
	G_DEFINE_TYPE (FlBinaryMessengerResponseHandle, fl_binary_messenger_response_handle, G_TYPE_OBJECT) static void fl_binary_messenger_response_handle_init(FlBinaryMessengerResponseHandle *self)
	G_DEFINE_TYPE (FlBinaryMessengerResponseHandleImpl, fl_binary_messenger_response_handle_impl, fl_binary_messenger_response_handle_get_type()) static void fl_binary_messenger_default_init(FlBinaryMessengerInterface *iface)
static void	fl_binary_messenger_response_handle_impl_dispose (GObject *object)
static void	fl_binary_messenger_response_handle_impl_class_init (FlBinaryMessengerResponseHandleImplClass *klass)
static void	fl_binary_messenger_response_handle_impl_init (FlBinaryMessengerResponseHandleImpl *self)
static FlBinaryMessengerResponseHandleImpl *	fl_binary_messenger_response_handle_impl_new (FlBinaryMessengerImpl *messenger, const FlutterPlatformMessageResponseHandle *response_handle)
static PlatformMessageHandler *	platform_message_handler_new (FlBinaryMessengerMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
static void	platform_message_handler_free (gpointer data)
static gboolean	fl_binary_messenger_platform_message_cb (FlEngine *engine, const gchar *channel, GBytes *message, const FlutterPlatformMessageResponseHandle *response_handle, void *user_data)
static void	fl_binary_messenger_impl_dispose (GObject *object)
static void	set_message_handler_on_channel (FlBinaryMessenger *messenger, const gchar *channel, FlBinaryMessengerMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
static gboolean	do_unref (gpointer value)
static gboolean	send_response (FlBinaryMessenger *messenger, FlBinaryMessengerResponseHandle *response_handle_, GBytes *response, GError **error)
static void	platform_message_ready_cb (GObject *object, GAsyncResult *result, gpointer user_data)
static void	send_on_channel (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
static GBytes *	send_on_channel_finish (FlBinaryMessenger *messenger, GAsyncResult *result, GError **error)
static gboolean	finish_method (GObject *object, GAsyncResult *result, GError **error)
static void	resize_channel_response_cb (GObject *object, GAsyncResult *result, gpointer user_data)
static void	resize_channel (FlBinaryMessenger *messenger, const gchar *channel, int64_t new_size)
static void	set_warns_on_channel_overflow_response_cb (GObject *object, GAsyncResult *result, gpointer user_data)
static void	set_warns_on_channel_overflow (FlBinaryMessenger *messenger, const gchar *channel, bool warns)
static void	shutdown (FlBinaryMessenger *messenger)
static void	fl_binary_messenger_impl_class_init (FlBinaryMessengerImplClass *klass)
static void	fl_binary_messenger_impl_init (FlBinaryMessengerImpl *self)
FlBinaryMessenger *	fl_binary_messenger_new (FlEngine *engine)
G_MODULE_EXPORT void	fl_binary_messenger_set_message_handler_on_channel (FlBinaryMessenger *self, const gchar *channel, FlBinaryMessengerMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
G_MODULE_EXPORT gboolean	fl_binary_messenger_send_response (FlBinaryMessenger *self, FlBinaryMessengerResponseHandle *response_handle, GBytes *response, GError **error)
G_MODULE_EXPORT void	fl_binary_messenger_send_on_channel (FlBinaryMessenger *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
G_MODULE_EXPORT GBytes *	fl_binary_messenger_send_on_channel_finish (FlBinaryMessenger *self, GAsyncResult *result, GError **error)
G_MODULE_EXPORT void	fl_binary_messenger_resize_channel (FlBinaryMessenger *self, const gchar *channel, int64_t new_size)
G_MODULE_EXPORT void	fl_binary_messenger_set_warns_on_channel_overflow (FlBinaryMessenger *self, const gchar *channel, bool warns)
gboolean	fl_binary_messenger_handle_message (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, const FlutterPlatformMessageResponseHandle *response_handle)
void	fl_binary_messenger_shutdown (FlBinaryMessenger *self)

Variables
static constexpr char	kControlChannelName [] = "dev.flutter/channel-buffers"
static constexpr char	kResizeMethod [] = "resize"
static constexpr char	kOverflowMethod [] = "overflow"
	fl_binary_messenger_impl
	FL
	BINARY_MESSENGER_IMPL

Function Documentation

do_unref()

static gboolean do_unref ( gpointer  value )

static

Definition at line 204 of file fl_binary_messenger.cc.

                                         {
  g_object_unref(value);
  return G_SOURCE_REMOVE;
}

References value.

Referenced by send_response().

finish_method()

static gboolean finish_method ( GObject *  object, GAsyncResult *  result, GError **  error  )

static

Definition at line 297 of file fl_binary_messenger.cc.

                                              {
  g_autoptr(GBytes) response = fl_binary_messenger_send_on_channel_finish(
      FL_BINARY_MESSENGER(object), result, error);
  if (response == nullptr) {
    return FALSE;
  }
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  return fl_method_codec_decode_response(FL_METHOD_CODEC(codec), response,
                                         error) != nullptr;
}

References error, fl_binary_messenger_send_on_channel_finish(), fl_method_codec_decode_response(), and fl_standard_method_codec_new().

Referenced by resize_channel_response_cb(), and set_warns_on_channel_overflow_response_cb().

fl_binary_messenger_handle_message()

gboolean fl_binary_messenger_handle_message	(	FlBinaryMessenger *	messenger,
		const gchar *	channel,
		GBytes *	message,
		const FlutterPlatformMessageResponseHandle *	response_handle
	)

fl_binary_messenger_handle_message: @messenger: an #FlBinaryMessenger. @channel: channel message received on. @message: message data. @response_handle: handle to provide to fl_engine_send_platform_message_response().

Handles a message received from the engine. Available for testing purposes.

Returns: TRUE if the message is handled.

Definition at line 478 of file fl_binary_messenger.cc.

                                                                 {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(messenger);
 
  PlatformMessageHandler* handler = static_cast<PlatformMessageHandler*>(
      g_hash_table_lookup(self->platform_message_handlers, channel));
  if (handler == nullptr) {
    return FALSE;
  }
 
  g_autoptr(FlBinaryMessengerResponseHandleImpl) handle =
      fl_binary_messenger_response_handle_impl_new(self, response_handle);
  handler->message_handler(FL_BINARY_MESSENGER(self), channel, message,
                           FL_BINARY_MESSENGER_RESPONSE_HANDLE(handle),
                           handler->message_handler_data);
 
  return TRUE;
}

References fl_binary_messenger_response_handle_impl_new(), PlatformMessageHandler::message_handler, PlatformMessageHandler::message_handler_data, and TRUE.

Referenced by fl_binary_messenger_platform_message_cb(), and TEST().

fl_binary_messenger_impl_class_init()

static void fl_binary_messenger_impl_class_init ( FlBinaryMessengerImplClass *  klass )

static

Definition at line 370 of file fl_binary_messenger.cc.

                                       {
  G_OBJECT_CLASS(klass)->dispose = fl_binary_messenger_impl_dispose;
}

References fl_binary_messenger_impl_dispose().

fl_binary_messenger_impl_dispose()

static void fl_binary_messenger_impl_dispose ( GObject *  object )

static

Definition at line 163 of file fl_binary_messenger.cc.

                                                              {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(object);
 
  g_weak_ref_clear(&self->engine);
 
  g_clear_pointer(&self->platform_message_handlers, g_hash_table_unref);
 
  G_OBJECT_CLASS(fl_binary_messenger_impl_parent_class)->dispose(object);
}

Referenced by fl_binary_messenger_impl_class_init().

fl_binary_messenger_impl_iface_init()

static void fl_binary_messenger_impl_iface_init ( FlBinaryMessengerInterface *  iface )

static

Definition at line 375 of file fl_binary_messenger.cc.

                                       {
  iface->set_message_handler_on_channel = set_message_handler_on_channel;
  iface->send_response = send_response;
  iface->send_on_channel = send_on_channel;
  iface->send_on_channel_finish = send_on_channel_finish;
  iface->resize_channel = resize_channel;
  iface->set_warns_on_channel_overflow = set_warns_on_channel_overflow;
  iface->shutdown = shutdown;
}

References resize_channel(), send_on_channel(), send_on_channel_finish(), send_response(), set_message_handler_on_channel(), set_warns_on_channel_overflow(), and shutdown().

fl_binary_messenger_impl_init()

static void fl_binary_messenger_impl_init ( FlBinaryMessengerImpl *  self )

static

Definition at line 386 of file fl_binary_messenger.cc.

                                                                       {
  self->platform_message_handlers = g_hash_table_new_full(
      g_str_hash, g_str_equal, g_free, platform_message_handler_free);
}

References platform_message_handler_free().

fl_binary_messenger_new()

FlBinaryMessenger* fl_binary_messenger_new

(

FlEngine *

engine

)

fl_binary_messenger_new: @engine: The #FlEngine to communicate with.

Creates a new #FlBinaryMessenger. The binary messenger will take control of the engines platform message handler.

Returns: a new #FlBinaryMessenger.

Definition at line 391 of file fl_binary_messenger.cc.

                                                             {
  g_return_val_if_fail(FL_IS_ENGINE(engine), nullptr);
 
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(
      g_object_new(fl_binary_messenger_impl_get_type(), nullptr));
 
  // Added to stop compiler complaining about an unused function.
  FL_IS_BINARY_MESSENGER_IMPL(self);
 
  g_weak_ref_init(&self->engine, G_OBJECT(engine));
 
  fl_engine_set_platform_message_handler(
      engine, fl_binary_messenger_platform_message_cb, self, NULL);
 
  return FL_BINARY_MESSENGER(self);
}

References fl_binary_messenger_platform_message_cb(), and fl_engine_set_platform_message_handler().

Referenced by fl_engine_new_with_renderer(), and TEST().

fl_binary_messenger_platform_message_cb()

static gboolean fl_binary_messenger_platform_message_cb ( FlEngine *  engine, const gchar *  channel, GBytes *  message, const FlutterPlatformMessageResponseHandle *  response_handle, void *  user_data  )

static

Definition at line 152 of file fl_binary_messenger.cc.

                     {
  FlBinaryMessenger* self = FL_BINARY_MESSENGER(user_data);
  return fl_binary_messenger_handle_message(self, channel, message,
                                            response_handle);
}

References fl_binary_messenger_handle_message(), and user_data.

Referenced by fl_binary_messenger_new().

fl_binary_messenger_resize_channel()

G_MODULE_EXPORT void fl_binary_messenger_resize_channel	(	FlBinaryMessenger *	messenger,
		const gchar *	channel,
		int64_t	new_size
	)

fl_binary_messenger_resize_channel: @binary_messenger: an #FlBinaryMessenger. @channel: channel to be resize. @new_size: the new size for the channel buffer.

Sends a message to the control channel asking to resize a channel buffer.

Definition at line 459 of file fl_binary_messenger.cc.

                                                                          {
  g_return_if_fail(FL_IS_BINARY_MESSENGER(self));
 
  return FL_BINARY_MESSENGER_GET_IFACE(self)->resize_channel(self, channel,
                                                             new_size);
}

Referenced by TEST().

fl_binary_messenger_response_handle_impl_class_init()

static void fl_binary_messenger_response_handle_impl_class_init ( FlBinaryMessengerResponseHandleImplClass *  klass )

static

Definition at line 103 of file fl_binary_messenger.cc.

                                                     {
  G_OBJECT_CLASS(klass)->dispose =
      fl_binary_messenger_response_handle_impl_dispose;
}

References fl_binary_messenger_response_handle_impl_dispose().

fl_binary_messenger_response_handle_impl_dispose()

static void fl_binary_messenger_response_handle_impl_dispose ( GObject *  object )

static

Definition at line 86 of file fl_binary_messenger.cc.

                                                                              {
  FlBinaryMessengerResponseHandleImpl* self =
      FL_BINARY_MESSENGER_RESPONSE_HANDLE_IMPL(object);
 
  g_autoptr(FlEngine) engine =
      FL_ENGINE(g_weak_ref_get(&self->messenger->engine));
  if (self->response_handle != nullptr && engine != nullptr) {
    g_critical("FlBinaryMessengerResponseHandle was not responded to");
  }
 
  g_clear_object(&self->messenger);
  self->response_handle = nullptr;
 
  G_OBJECT_CLASS(fl_binary_messenger_response_handle_impl_parent_class)
      ->dispose(object);
}

Referenced by fl_binary_messenger_response_handle_impl_class_init().

fl_binary_messenger_response_handle_impl_init()

static void fl_binary_messenger_response_handle_impl_init ( FlBinaryMessengerResponseHandleImpl *  self )

static

Definition at line 109 of file fl_binary_messenger.cc.

                                               {}

fl_binary_messenger_response_handle_impl_new()

static FlBinaryMessengerResponseHandleImpl* fl_binary_messenger_response_handle_impl_new ( FlBinaryMessengerImpl *  messenger, const FlutterPlatformMessageResponseHandle *  response_handle  )

static

Definition at line 113 of file fl_binary_messenger.cc.

                                                                 {
  FlBinaryMessengerResponseHandleImpl* self =
      FL_BINARY_MESSENGER_RESPONSE_HANDLE_IMPL(g_object_new(
          fl_binary_messenger_response_handle_impl_get_type(), nullptr));
 
  self->messenger = FL_BINARY_MESSENGER_IMPL(g_object_ref(messenger));
  self->response_handle = response_handle;
 
  return self;
}

Referenced by fl_binary_messenger_handle_message().

fl_binary_messenger_send_on_channel()

G_MODULE_EXPORT void fl_binary_messenger_send_on_channel	(	FlBinaryMessenger *	messenger,
		const gchar *	channel,
		GBytes *	message,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_binary_messenger_send_on_channel: @binary_messenger: an #FlBinaryMessenger. @channel: channel to send to. @message: (allow-none): message buffer to send or NULL for an empty message. @cancellable: (allow-none): a #GCancellable or NULL. @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied. @user_data: (closure): user data to pass to @callback.

Asynchronously sends a platform message.

Definition at line 435 of file fl_binary_messenger.cc.

                        {
  g_return_if_fail(FL_IS_BINARY_MESSENGER(self));
  g_return_if_fail(channel != nullptr);
 
  FL_BINARY_MESSENGER_GET_IFACE(self)->send_on_channel(
      self, channel, message, cancellable, callback, user_data);
}

References user_data.

Referenced by fl_basic_message_channel_send(), fl_event_channel_send(), fl_event_channel_send_end_of_stream(), fl_event_channel_send_error(), fl_method_channel_invoke_method(), resize_channel(), send_lifecycle_state(), set_warns_on_channel_overflow(), and TEST().

fl_binary_messenger_send_on_channel_finish()

G_MODULE_EXPORT GBytes* fl_binary_messenger_send_on_channel_finish	(	FlBinaryMessenger *	messenger,
		GAsyncResult *	result,
		GError **	error
	)

fl_binary_messenger_send_on_channel_finish: @messenger: an #FlBinaryMessenger.

Returns

: a #GAsyncResult. @error: (allow-none): #GError location to store the error occurring, or NULL to ignore.

Completes request started with fl_binary_messenger_send_on_channel().

Returns: (transfer full): message response on success or NULL on error.

Definition at line 449 of file fl_binary_messenger.cc.

                    {
  g_return_val_if_fail(FL_IS_BINARY_MESSENGER(self), FALSE);
 
  return FL_BINARY_MESSENGER_GET_IFACE(self)->send_on_channel_finish(
      self, result, error);
}

References error.

Referenced by finish_method(), fl_basic_message_channel_send_finish(), fl_method_channel_invoke_method_finish(), and TEST().

fl_binary_messenger_send_response()

G_MODULE_EXPORT gboolean fl_binary_messenger_send_response	(	FlBinaryMessenger *	messenger,
		FlBinaryMessengerResponseHandle *	response_handle,
		GBytes *	response,
		GError **	error
	)

fl_binary_messenger_send_response: @binary_messenger: an #FlBinaryMessenger. @response_handle: handle that was provided in a FlBinaryMessengerMessageHandler. @response: (allow-none): response to send or NULL for an empty response. @error: (allow-none): #GError location to store the error occurring, or NULL to ignore.

Responds to a platform message. This function is thread-safe.

Returns: TRUE on success.

Definition at line 422 of file fl_binary_messenger.cc.

                    {
  g_return_val_if_fail(FL_IS_BINARY_MESSENGER(self), FALSE);
  g_return_val_if_fail(FL_IS_BINARY_MESSENGER_RESPONSE_HANDLE(response_handle),
                       FALSE);
 
  return FL_BINARY_MESSENGER_GET_IFACE(self)->send_response(
      self, response_handle, response, error);
}

References error.

Referenced by fl_basic_message_channel_respond(), fl_method_channel_respond(), message_cb(), and TEST().

fl_binary_messenger_set_message_handler_on_channel()

G_MODULE_EXPORT void fl_binary_messenger_set_message_handler_on_channel	(	FlBinaryMessenger *	messenger,
		const gchar *	channel,
		FlBinaryMessengerMessageHandler	handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

FlBinaryMessenger:

#FlBinaryMessenger is an object that allows sending and receiving of platform messages with an #FlEngine. FlBinaryMessengerResponseHandle:

#FlBinaryMessengerResponseHandle is an object used to send responses with. fl_binary_messenger_set_platform_message_handler: @binary_messenger: an #FlBinaryMessenger. @channel: channel to listen on. @handler: (allow-none): function to call when a message is received on this channel or NULL to disable a handler @user_data: (closure): user data to pass to @handler. @destroy_notify: (allow-none): a function which gets called to free @user_data, or NULL.

Sets the function called when a platform message is received on the given channel. See FlBinaryMessengerMessageHandler for details on how to respond to messages.

The handler is removed if the channel is closed or is replaced by another handler, set @destroy_notify if you want to detect this.

Definition at line 408 of file fl_binary_messenger.cc.

                                   {
  g_return_if_fail(FL_IS_BINARY_MESSENGER(self));
  g_return_if_fail(channel != nullptr);
 
  FL_BINARY_MESSENGER_GET_IFACE(self)->set_message_handler_on_channel(
      self, channel, handler, user_data, destroy_notify);
}

References user_data.

Referenced by fl_basic_message_channel_dispose(), fl_basic_message_channel_new(), fl_event_channel_dispose(), fl_event_channel_new(), fl_method_channel_new(), and TEST().

fl_binary_messenger_set_warns_on_channel_overflow()

G_MODULE_EXPORT void fl_binary_messenger_set_warns_on_channel_overflow	(	FlBinaryMessenger *	messenger,
		const gchar *	channel,
		bool	warns
	)

fl_binary_messenger_set_warns_on_channel_overflow: @messenger: an #FlBinaryMessenger. @channel: channel to be allowed to overflow silently. @warns: when false, the channel is expected to overflow and warning messages will not be shown.

Sends a message to the control channel asking to allow or disallow a channel to overflow silently.

Definition at line 468 of file fl_binary_messenger.cc.

                {
  g_return_if_fail(FL_IS_BINARY_MESSENGER(self));
 
  return FL_BINARY_MESSENGER_GET_IFACE(self)->set_warns_on_channel_overflow(
      self, channel, warns);
}

Referenced by TEST().

fl_binary_messenger_shutdown()

void fl_binary_messenger_shutdown

(

FlBinaryMessenger *

messenger

)

fl_binary_messenger_shutdown: @messenger: an #FlBinaryMessenger.

Shutdown the messenger closing any open channels.

Definition at line 500 of file fl_binary_messenger.cc.

                                                           {
  g_return_if_fail(FL_IS_BINARY_MESSENGER(self));
 
  return FL_BINARY_MESSENGER_GET_IFACE(self)->shutdown(self);
}

Referenced by fl_engine_dispose(), fl_test_application_activate(), TEST(), and test_lock_event().

G_DECLARE_FINAL_TYPE()

GObject G_DECLARE_FINAL_TYPE	(	FlBinaryMessengerResponseHandleImpl	,
		fl_binary_messenger_response_handle_impl	,
		FL	,
		BINARY_MESSENGER_RESPONSE_HANDLE_IMPL	,
		FlBinaryMessengerResponseHandle
	)

Definition at line 31 of file fl_binary_messenger.cc.

                              {
  GObject parent_instance;
 
  GWeakRef engine;
 
  // PlatformMessageHandler keyed by channel name.
  GHashTable* platform_message_handlers;
};

G_DEFINE_QUARK()

G_DEFINE_QUARK	(	fl_binary_messenger_codec_error_quark	,
		fl_binary_messenger_codec_error
	)

G_DEFINE_TYPE() [1/2]

G_DEFINE_TYPE	(	FlBinaryMessengerResponseHandle	,
		fl_binary_messenger_response_handle	,
		G_TYPE_OBJECT
	)

Definition at line 61 of file fl_binary_messenger.cc.

                                           {}

G_DEFINE_TYPE() [2/2]

G_DEFINE_TYPE	(	FlBinaryMessengerResponseHandleImpl	,
		fl_binary_messenger_response_handle_impl	,
		fl_binary_messenger_response_handle_get_type()
	)

Definition at line 79 of file fl_binary_messenger.cc.

                                       {}

G_DEFINE_TYPE_WITH_CODE()

G_DEFINE_TYPE_WITH_CODE	(	FlBinaryMessengerImpl	,
		fl_binary_messenger_impl	,
		G_TYPE_OBJECT	,
		G_IMPLEMENT_INTERFACE(fl_binary_messenger_get_type(), fl_binary_messenger_impl_iface_init)
	)

Definition at line 51 of file fl_binary_messenger.cc.

                                                 {}

platform_message_handler_free()

static void platform_message_handler_free ( gpointer  data )

static

Definition at line 144 of file fl_binary_messenger.cc.

                                                         {
  PlatformMessageHandler* self = static_cast<PlatformMessageHandler*>(data);
  if (self->message_handler_destroy_notify) {
    self->message_handler_destroy_notify(self->message_handler_data);
  }
  g_free(self);
}

References PlatformMessageHandler::message_handler_destroy_notify.

Referenced by fl_binary_messenger_impl_init(), and shutdown().

platform_message_handler_new()

static PlatformMessageHandler* platform_message_handler_new ( FlBinaryMessengerMessageHandler  handler, gpointer  user_data, GDestroyNotify  destroy_notify  )

static

Definition at line 132 of file fl_binary_messenger.cc.

                                   {
  PlatformMessageHandler* self = static_cast<PlatformMessageHandler*>(
      g_malloc0(sizeof(PlatformMessageHandler)));
  self->message_handler = handler;
  self->message_handler_data = user_data;
  self->message_handler_destroy_notify = destroy_notify;
  return self;
}

References PlatformMessageHandler::message_handler, and user_data.

Referenced by set_message_handler_on_channel().

platform_message_ready_cb()

static void platform_message_ready_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 248 of file fl_binary_messenger.cc.

                                                          {
  g_autoptr(GTask) task = G_TASK(user_data);
  g_task_return_pointer(task, g_object_ref(result), g_object_unref);
}

References user_data.

Referenced by send_on_channel().

resize_channel()

static void resize_channel ( FlBinaryMessenger *  messenger, const gchar *  channel, int64_t  new_size  )

static

Definition at line 320 of file fl_binary_messenger.cc.

                                             {
  FML_DCHECK(new_size >= 0);
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlValue) args = fl_value_new_list();
  fl_value_append_take(args, fl_value_new_string(channel));
  fl_value_append_take(args, fl_value_new_int(new_size));
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), kResizeMethod, args, nullptr);
  fl_binary_messenger_send_on_channel(messenger, kControlChannelName, message,
                                      nullptr, resize_channel_response_cb,
                                      nullptr);
}

References args, fl_binary_messenger_send_on_channel(), fl_method_codec_encode_method_call(), fl_standard_method_codec_new(), fl_value_append_take(), fl_value_new_int(), fl_value_new_list(), fl_value_new_string(), kControlChannelName, kResizeMethod, and resize_channel_response_cb().

Referenced by fl_binary_messenger_impl_iface_init().

resize_channel_response_cb()

static void resize_channel_response_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 311 of file fl_binary_messenger.cc.

                                                           {
  g_autoptr(GError) error = nullptr;
  if (!finish_method(object, result, &error)) {
    g_warning("Failed to resize channel: %s", error->message);
  }
}

References error, and finish_method().

Referenced by resize_channel().

send_on_channel()

static void send_on_channel ( FlBinaryMessenger *  messenger, const gchar *  channel, GBytes *  message, GCancellable *  cancellable, GAsyncReadyCallback  callback, gpointer  user_data  )

static

Definition at line 255 of file fl_binary_messenger.cc.

                                                {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(messenger);
 
  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine == nullptr) {
    return;
  }
 
  fl_engine_send_platform_message(
      engine, channel, message, cancellable,
      callback != nullptr ? platform_message_ready_cb : nullptr,
      callback != nullptr ? g_task_new(self, cancellable, callback, user_data)
                          : nullptr);
}

References fl_engine_send_platform_message(), platform_message_ready_cb(), and user_data.

Referenced by fl_binary_messenger_impl_iface_init().

send_on_channel_finish()

static GBytes* send_on_channel_finish ( FlBinaryMessenger *  messenger, GAsyncResult *  result, GError **  error  )

static

Definition at line 275 of file fl_binary_messenger.cc.

                                                      {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(messenger);
  g_return_val_if_fail(g_task_is_valid(result, self), FALSE);
 
  GTask* task = G_TASK(result);
  g_autoptr(GAsyncResult) r =
      G_ASYNC_RESULT(g_task_propagate_pointer(task, error));
  if (r == nullptr) {
    return nullptr;
  }
 
  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine == nullptr) {
    return nullptr;
  }
 
  return fl_engine_send_platform_message_finish(engine, r, error);
}

References error, and fl_engine_send_platform_message_finish().

Referenced by fl_binary_messenger_impl_iface_init().

send_response()

static gboolean send_response ( FlBinaryMessenger *  messenger, FlBinaryMessengerResponseHandle *  response_handle_, GBytes *  response, GError **  error  )

static

Definition at line 210 of file fl_binary_messenger.cc.

                                              {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(messenger);
  g_return_val_if_fail(
      FL_IS_BINARY_MESSENGER_RESPONSE_HANDLE_IMPL(response_handle_), FALSE);
  FlBinaryMessengerResponseHandleImpl* response_handle =
      FL_BINARY_MESSENGER_RESPONSE_HANDLE_IMPL(response_handle_);
 
  g_return_val_if_fail(response_handle->messenger == self, FALSE);
  g_return_val_if_fail(response_handle->response_handle != nullptr, FALSE);
 
  FlEngine* engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine == nullptr) {
    return TRUE;
  }
 
  gboolean result = false;
  if (response_handle->response_handle == nullptr) {
    g_set_error(
        error, FL_BINARY_MESSENGER_ERROR,
        FL_BINARY_MESSENGER_ERROR_ALREADY_RESPONDED,
        "Attempted to respond to a message that is already responded to");
    result = FALSE;
  } else {
    result = fl_engine_send_platform_message_response(
        engine, response_handle->response_handle, response, error);
    response_handle->response_handle = nullptr;
  }
 
  // This guarantees that the dispose method for the engine is executed
  // on the platform thread in the rare chance this is the last ref.
  g_idle_add(do_unref, engine);
 
  return result;
}

References do_unref(), error, FL_BINARY_MESSENGER_ERROR, FL_BINARY_MESSENGER_ERROR_ALREADY_RESPONDED, fl_engine_send_platform_message_response(), and TRUE.

Referenced by fl_binary_messenger_impl_iface_init().

set_message_handler_on_channel()

static void set_message_handler_on_channel ( FlBinaryMessenger *  messenger, const gchar *  channel, FlBinaryMessengerMessageHandler  handler, gpointer  user_data, GDestroyNotify  destroy_notify  )

static

Definition at line 173 of file fl_binary_messenger.cc.

                                   {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(messenger);
 
  // Don't set handlers if engine already gone.
  g_autoptr(FlEngine) engine = FL_ENGINE(g_weak_ref_get(&self->engine));
  if (engine == nullptr) {
    if (handler != nullptr) {
      g_warning(
          "Attempted to set message handler on an FlBinaryMessenger without an "
          "engine");
    }
    if (destroy_notify != nullptr) {
      destroy_notify(user_data);
    }
    return;
  }
 
  if (handler != nullptr) {
    g_hash_table_replace(
        self->platform_message_handlers, g_strdup(channel),
        platform_message_handler_new(handler, user_data, destroy_notify));
  } else {
    g_hash_table_remove(self->platform_message_handlers, channel);
  }
}

References platform_message_handler_new(), and user_data.

Referenced by fl_binary_messenger_impl_iface_init().

set_warns_on_channel_overflow()

static void set_warns_on_channel_overflow ( FlBinaryMessenger *  messenger, const gchar *  channel, bool  warns  )

static

Definition at line 345 of file fl_binary_messenger.cc.

                                                      {
  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
  g_autoptr(FlValue) args = fl_value_new_list();
  fl_value_append_take(args, fl_value_new_string(channel));
  fl_value_append_take(args, fl_value_new_bool(!warns));
  g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
      FL_METHOD_CODEC(codec), kOverflowMethod, args, nullptr);
  fl_binary_messenger_send_on_channel(
      messenger, kControlChannelName, message, nullptr,
      set_warns_on_channel_overflow_response_cb, nullptr);
}

References args, fl_binary_messenger_send_on_channel(), fl_method_codec_encode_method_call(), fl_standard_method_codec_new(), fl_value_append_take(), fl_value_new_bool(), fl_value_new_list(), fl_value_new_string(), kControlChannelName, kOverflowMethod, and set_warns_on_channel_overflow_response_cb().

Referenced by fl_binary_messenger_impl_iface_init().

set_warns_on_channel_overflow_response_cb()

static void set_warns_on_channel_overflow_response_cb ( GObject *  object, GAsyncResult *  result, gpointer  user_data  )

static

Definition at line 336 of file fl_binary_messenger.cc.

                                                                          {
  g_autoptr(GError) error = nullptr;
  if (!finish_method(object, result, &error)) {
    g_warning("Failed to set warns on channel overflow: %s", error->message);
  }
}

References error, and finish_method().

Referenced by set_warns_on_channel_overflow().

shutdown()

static void shutdown ( FlBinaryMessenger *  messenger )

static

Definition at line 359 of file fl_binary_messenger.cc.

                                                   {
  FlBinaryMessengerImpl* self = FL_BINARY_MESSENGER_IMPL(messenger);
 
  // Disconnect any handlers.
  // Take the reference in case a handler tries to modify this table.
  g_autoptr(GHashTable) handlers = self->platform_message_handlers;
  self->platform_message_handlers = g_hash_table_new_full(
      g_str_hash, g_str_equal, g_free, platform_message_handler_free);
  g_hash_table_remove_all(handlers);
}

References platform_message_handler_free().

Referenced by fl_binary_messenger_impl_iface_init(), and G_DECLARE_INTERFACE().

Variable Documentation

BINARY_MESSENGER_IMPL

BINARY_MESSENGER_IMPL

Definition at line 28 of file fl_binary_messenger.cc.

FL

FL

Definition at line 27 of file fl_binary_messenger.cc.

fl_binary_messenger_impl

fl_binary_messenger_impl

Definition at line 26 of file fl_binary_messenger.cc.

kControlChannelName

constexpr char kControlChannelName[] = "dev.flutter/channel-buffers"

staticconstexpr

Definition at line 18 of file fl_binary_messenger.cc.

Referenced by resize_channel(), flutter::internal::ResizeChannel(), set_warns_on_channel_overflow(), and flutter::internal::SetChannelWarnsOnOverflow().

kOverflowMethod

constexpr char kOverflowMethod[] = "overflow"

staticconstexpr

Definition at line 20 of file fl_binary_messenger.cc.

Referenced by set_warns_on_channel_overflow(), and flutter::internal::SetChannelWarnsOnOverflow().

kResizeMethod

constexpr char kResizeMethod[] = "resize"

staticconstexpr

Definition at line 19 of file fl_binary_messenger.cc.

Referenced by resize_channel(), and flutter::internal::ResizeChannel().