fl_basic_message_channel.cc File Reference

#include "flutter/shell/platform/linux/public/flutter_linux/fl_basic_message_channel.h"
#include <gmodule.h>

Go to the source code of this file.

Classes
struct	_FlBasicMessageChannel
struct	_FlBasicMessageChannelResponseHandle

Functions
	G_DEFINE_TYPE (FlBasicMessageChannelResponseHandle, fl_basic_message_channel_response_handle, G_TYPE_OBJECT) static void fl_basic_message_channel_response_handle_dispose(GObject *object)
static void	fl_basic_message_channel_response_handle_class_init (FlBasicMessageChannelResponseHandleClass *klass)
static void	fl_basic_message_channel_response_handle_init (FlBasicMessageChannelResponseHandle *self)
static FlBasicMessageChannelResponseHandle *	fl_basic_message_channel_response_handle_new (FlBinaryMessengerResponseHandle *response_handle)
static void	message_cb (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)
static void	message_response_cb (GObject *object, GAsyncResult *result, gpointer user_data)
static void	channel_closed_cb (gpointer user_data)
static void	fl_basic_message_channel_dispose (GObject *object)
static void	fl_basic_message_channel_class_init (FlBasicMessageChannelClass *klass)
static void	fl_basic_message_channel_init (FlBasicMessageChannel *self)
G_MODULE_EXPORT FlBasicMessageChannel *	fl_basic_message_channel_new (FlBinaryMessenger *messenger, const gchar *name, FlMessageCodec *codec)
G_MODULE_EXPORT void	fl_basic_message_channel_set_message_handler (FlBasicMessageChannel *self, FlBasicMessageChannelMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
G_MODULE_EXPORT gboolean	fl_basic_message_channel_respond (FlBasicMessageChannel *self, FlBasicMessageChannelResponseHandle *response_handle, FlValue *message, GError **error)
G_MODULE_EXPORT void	fl_basic_message_channel_send (FlBasicMessageChannel *self, FlValue *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
G_MODULE_EXPORT FlValue *	fl_basic_message_channel_send_finish (FlBasicMessageChannel *self, GAsyncResult *result, GError **error)

Function Documentation

channel_closed_cb()

static void channel_closed_cb ( gpointer  user_data )

static

Definition at line 111 of file fl_basic_message_channel.cc.

                                                  {
  g_autoptr(FlBasicMessageChannel) self = FL_BASIC_MESSAGE_CHANNEL(user_data);
 
  self->channel_closed = TRUE;
 
  // Disconnect handler.
  if (self->message_handler_destroy_notify != nullptr) {
    self->message_handler_destroy_notify(self->message_handler_data);
  }
  self->message_handler = nullptr;
  self->message_handler_data = nullptr;
  self->message_handler_destroy_notify = nullptr;
}

References TRUE, and user_data.

Referenced by fl_basic_message_channel_new().

fl_basic_message_channel_class_init()

static void fl_basic_message_channel_class_init ( FlBasicMessageChannelClass *  klass )

static

Definition at line 147 of file fl_basic_message_channel.cc.

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

References fl_basic_message_channel_dispose().

fl_basic_message_channel_dispose()

static void fl_basic_message_channel_dispose ( GObject *  object )

static

Definition at line 125 of file fl_basic_message_channel.cc.

                                                              {
  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(object);
 
  if (self->messenger != nullptr) {
    fl_binary_messenger_set_message_handler_on_channel(
        self->messenger, self->name, nullptr, nullptr, nullptr);
  }
 
  g_clear_object(&self->messenger);
  g_clear_pointer(&self->name, g_free);
  g_clear_object(&self->codec);
 
  if (self->message_handler_destroy_notify != nullptr) {
    self->message_handler_destroy_notify(self->message_handler_data);
  }
  self->message_handler = nullptr;
  self->message_handler_data = nullptr;
  self->message_handler_destroy_notify = nullptr;
 
  G_OBJECT_CLASS(fl_basic_message_channel_parent_class)->dispose(object);
}

References fl_binary_messenger_set_message_handler_on_channel().

Referenced by fl_basic_message_channel_class_init().

fl_basic_message_channel_init()

static void fl_basic_message_channel_init ( FlBasicMessageChannel *  self )

static

Definition at line 152 of file fl_basic_message_channel.cc.

{}

fl_basic_message_channel_new()

G_MODULE_EXPORT FlBasicMessageChannel* fl_basic_message_channel_new	(	FlBinaryMessenger *	messenger,
		const gchar *	name,
		FlMessageCodec *	codec
	)

Definition at line 154 of file fl_basic_message_channel.cc.

                           {
  g_return_val_if_fail(FL_IS_BINARY_MESSENGER(messenger), nullptr);
  g_return_val_if_fail(name != nullptr, nullptr);
  g_return_val_if_fail(FL_IS_MESSAGE_CODEC(codec), nullptr);
 
  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(
      g_object_new(fl_basic_message_channel_get_type(), nullptr));
 
  self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger));
  self->name = g_strdup(name);
  self->codec = FL_MESSAGE_CODEC(g_object_ref(codec));
 
  fl_binary_messenger_set_message_handler_on_channel(
      self->messenger, self->name, message_cb, g_object_ref(self),
      channel_closed_cb);
 
  return self;
}

References channel_closed_cb(), fl_binary_messenger_set_message_handler_on_channel(), and message_cb().

Referenced by fl_key_channel_responder_new(), fl_settings_handler_new(), and TEST().

fl_basic_message_channel_respond()

G_MODULE_EXPORT gboolean fl_basic_message_channel_respond	(	FlBasicMessageChannel *	channel,
		FlBasicMessageChannelResponseHandle *	response_handle,
		FlValue *	message,
		GError **	error
	)

fl_basic_message_channel_respond: @channel: an #FlBasicMessageChannel. @response_handle: handle that was provided in a FlBasicMessageChannelMessageHandler. @message: (allow-none): message 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 message.

Returns: TRUE on success.

Definition at line 204 of file fl_basic_message_channel.cc.

                    {
  g_return_val_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self), FALSE);
  g_return_val_if_fail(response_handle != nullptr, FALSE);
  g_return_val_if_fail(response_handle->response_handle != nullptr, FALSE);
 
  g_autoptr(GBytes) data =
      fl_message_codec_encode_message(self->codec, message, error);
  if (data == nullptr) {
    return FALSE;
  }
 
  gboolean result = fl_binary_messenger_send_response(
      self->messenger, response_handle->response_handle, data, error);
  g_clear_object(&response_handle->response_handle);
 
  return result;
}

References error, fl_binary_messenger_send_response(), fl_message_codec_encode_message(), and result.

Referenced by message_cb(), and response_cb().

fl_basic_message_channel_response_handle_class_init()

static void fl_basic_message_channel_response_handle_class_init ( FlBasicMessageChannelResponseHandleClass *  klass )

static

Definition at line 51 of file fl_basic_message_channel.cc.

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

fl_basic_message_channel_response_handle_init()

static void fl_basic_message_channel_response_handle_init ( FlBasicMessageChannelResponseHandle *  self )

static

Definition at line 57 of file fl_basic_message_channel.cc.

                                               {}

fl_basic_message_channel_response_handle_new()

static FlBasicMessageChannelResponseHandle* fl_basic_message_channel_response_handle_new ( FlBinaryMessengerResponseHandle *  response_handle )

static

Definition at line 61 of file fl_basic_message_channel.cc.

                                                      {
  FlBasicMessageChannelResponseHandle* self =
      FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(g_object_new(
          fl_basic_message_channel_response_handle_get_type(), nullptr));
 
  self->response_handle =
      FL_BINARY_MESSENGER_RESPONSE_HANDLE(g_object_ref(response_handle));
 
  return self;
}

Referenced by message_cb().

fl_basic_message_channel_send()

G_MODULE_EXPORT void fl_basic_message_channel_send	(	FlBasicMessageChannel *	channel,
		FlValue *	message,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_basic_message_channel_send: @channel: an #FlBasicMessageChannel. @message: (allow-none): message to send, must match what the #FlMessageCodec supports. @cancellable: (allow-none): a #GCancellable or NULL. @callback: (scope async): (allow-none): a #GAsyncReadyCallback to call when the request is satisfied or NULL to ignore the response. @user_data: (closure): user data to pass to @callback.

Asynchronously sends a message.

Definition at line 226 of file fl_basic_message_channel.cc.

                                                                       {
  g_return_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self));
 
  g_autoptr(GTask) task =
      callback != nullptr ? g_task_new(self, cancellable, callback, user_data)
                          : nullptr;
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(GBytes) data =
      fl_message_codec_encode_message(self->codec, message, &error);
  if (data == nullptr) {
    if (task != nullptr) {
      g_task_return_error(task, error);
    }
    return;
  }
 
  fl_binary_messenger_send_on_channel(
      self->messenger, self->name, data, cancellable,
      callback != nullptr ? message_response_cb : nullptr,
      g_steal_pointer(&task));
}

References callback, error, fl_binary_messenger_send_on_channel(), fl_message_codec_encode_message(), message_response_cb(), and user_data.

Referenced by fl_key_channel_responder_handle_event(), TEST(), and update_settings().

fl_basic_message_channel_send_finish()

G_MODULE_EXPORT FlValue* fl_basic_message_channel_send_finish	(	FlBasicMessageChannel *	channel,
		GAsyncResult *	result,
		GError **	error
	)

fl_basic_message_channel_send_finish: @channel: an #FlBasicMessageChannel.

Returns

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

Completes request started with fl_basic_message_channel_send().

Returns: message response on success or NULL on error.

Definition at line 253 of file fl_basic_message_channel.cc.

                    {
  g_return_val_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self), nullptr);
  g_return_val_if_fail(g_task_is_valid(result, self), nullptr);
 
  g_autoptr(GTask) task = G_TASK(result);
  GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr));
 
  g_autoptr(GBytes) message =
      fl_binary_messenger_send_on_channel_finish(self->messenger, r, error);
  if (message == nullptr) {
    return nullptr;
  }
 
  return fl_message_codec_decode_message(self->codec, message, error);
}

References error, fl_binary_messenger_send_on_channel_finish(), fl_message_codec_decode_message(), and result.

Referenced by echo_response_cb(), failure_response_cb(), handle_response(), and null_message_response_cb().

fl_basic_message_channel_set_message_handler()

G_MODULE_EXPORT void fl_basic_message_channel_set_message_handler	(	FlBasicMessageChannel *	channel,
		FlBasicMessageChannelMessageHandler	handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

fl_basic_message_channel_set_message_handler: @channel: an #FlBasicMessageChannel. @handler: (allow-none): function to call when a message is received on this channel or NULL to disable the 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 message is received from the Dart side of the channel. See FlBasicMessageChannelMessageHandler 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 176 of file fl_basic_message_channel.cc.

                                   {
  g_return_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self));
 
  // Don't set handler if channel closed.
  if (self->channel_closed) {
    if (handler != nullptr) {
      g_warning(
          "Attempted to set message handler on a closed FlBasicMessageChannel");
    }
    if (destroy_notify != nullptr) {
      destroy_notify(user_data);
    }
    return;
  }
 
  if (self->message_handler_destroy_notify != nullptr) {
    self->message_handler_destroy_notify(self->message_handler_data);
  }
 
  self->message_handler = handler;
  self->message_handler_data = user_data;
  self->message_handler_destroy_notify = destroy_notify;
}

References user_data.

Referenced by TEST().

G_DEFINE_TYPE()

G_DEFINE_TYPE	(	FlBasicMessageChannelResponseHandle	,
		fl_basic_message_channel_response_handle	,
		G_TYPE_OBJECT
	)

Definition at line 37 of file fl_basic_message_channel.cc.

                                                                              {
  FlBasicMessageChannelResponseHandle* self =
      FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(object);
 
  g_clear_object(&self->response_handle);
 
  G_OBJECT_CLASS(fl_basic_message_channel_response_handle_parent_class)
      ->dispose(object);
}

message_cb()

static void message_cb ( FlBinaryMessenger *  messenger, const gchar *  channel, GBytes *  message, FlBinaryMessengerResponseHandle *  response_handle, gpointer  user_data  )

static

Definition at line 74 of file fl_basic_message_channel.cc.

                                           {
  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(user_data);
 
  if (self->message_handler == nullptr) {
    fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                      nullptr);
    return;
  }
 
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) message_value =
      fl_message_codec_decode_message(self->codec, message, &error);
  if (message_value == nullptr) {
    g_warning("Failed to decode message: %s", error->message);
    fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                      nullptr);
  }
 
  g_autoptr(FlBasicMessageChannelResponseHandle) handle =
      fl_basic_message_channel_response_handle_new(response_handle);
  self->message_handler(self, message_value, handle,
                        self->message_handler_data);
}

References error, fl_basic_message_channel_response_handle_new(), fl_binary_messenger_send_response(), fl_message_codec_decode_message(), and user_data.

Referenced by fl_basic_message_channel_new().

message_response_cb()

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

static

Definition at line 103 of file fl_basic_message_channel.cc.

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

References result, and user_data.

Referenced by fl_basic_message_channel_send().