fl_event_channel.cc File Reference

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

Go to the source code of this file.

Classes
struct	_FlEventChannel
struct	_FlEventChannelResponseHandle

Functions
static FlMethodErrorResponse *	handle_method_call (FlEventChannel *self, const gchar *name, FlValue *args)
static void	message_cb (FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)
static void	remove_handlers (FlEventChannel *self)
static void	channel_closed_cb (gpointer user_data)
static void	fl_event_channel_dispose (GObject *object)
static void	fl_event_channel_class_init (FlEventChannelClass *klass)
static void	fl_event_channel_init (FlEventChannel *self)
G_MODULE_EXPORT FlEventChannel *	fl_event_channel_new (FlBinaryMessenger *messenger, const gchar *name, FlMethodCodec *codec)
G_MODULE_EXPORT void	fl_event_channel_set_stream_handlers (FlEventChannel *self, FlEventChannelHandler listen_handler, FlEventChannelHandler cancel_handler, gpointer user_data, GDestroyNotify destroy_notify)
G_MODULE_EXPORT gboolean	fl_event_channel_send (FlEventChannel *self, FlValue *event, GCancellable *cancellable, GError **error)
G_MODULE_EXPORT gboolean	fl_event_channel_send_error (FlEventChannel *self, const gchar *code, const gchar *message, FlValue *details, GCancellable *cancellable, GError **error)
G_MODULE_EXPORT gboolean	fl_event_channel_send_end_of_stream (FlEventChannel *self, GCancellable *cancellable, GError **error)

Variables
static constexpr char	kListenMethod [] = "listen"
static constexpr char	kCancelMethod [] = "cancel"
static constexpr char	kEventRequestError [] = "error"

Function Documentation

channel_closed_cb()

static void channel_closed_cb ( gpointer  user_data )

static

Definition at line 130 of file fl_event_channel.cc.

                                                  {
  g_autoptr(FlEventChannel) self = FL_EVENT_CHANNEL(user_data);
  self->channel_closed = TRUE;
  remove_handlers(self);
}

References remove_handlers(), TRUE, and user_data.

Referenced by fl_event_channel_new().

fl_event_channel_class_init()

static void fl_event_channel_class_init ( FlEventChannelClass *  klass )

static

Definition at line 153 of file fl_event_channel.cc.

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

References fl_event_channel_dispose().

fl_event_channel_dispose()

static void fl_event_channel_dispose ( GObject *  object )

static

Definition at line 136 of file fl_event_channel.cc.

                                                      {
  FlEventChannel* self = FL_EVENT_CHANNEL(object);
 
  if (!self->channel_closed) {
    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);
 
  remove_handlers(self);
 
  G_OBJECT_CLASS(fl_event_channel_parent_class)->dispose(object);
}

References fl_binary_messenger_set_message_handler_on_channel(), and remove_handlers().

Referenced by fl_event_channel_class_init().

fl_event_channel_init()

static void fl_event_channel_init ( FlEventChannel *  self )

static

Definition at line 157 of file fl_event_channel.cc.

{}

fl_event_channel_new()

G_MODULE_EXPORT FlEventChannel* fl_event_channel_new	(	FlBinaryMessenger *	messenger,
		const gchar *	name,
		FlMethodCodec *	codec
	)

Definition at line 159 of file fl_event_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_METHOD_CODEC(codec), nullptr);
 
  FlEventChannel* self =
      FL_EVENT_CHANNEL(g_object_new(fl_event_channel_get_type(), nullptr));
 
  self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger));
  self->name = g_strdup(name);
  self->codec = FL_METHOD_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 TEST().

fl_event_channel_send()

G_MODULE_EXPORT gboolean fl_event_channel_send	(	FlEventChannel *	channel,
		FlValue *	event,
		GCancellable *	cancellable,
		GError **	error
	)

fl_event_channel_send: @channel: an #FlEventChannel. @event: event to send, must match what the #FlMethodCodec supports. @cancellable: (allow-none): a #GCancellable or NULL. @error: (allow-none): #GError location to store the error occurring, or NULL to ignore.

Sends an event on the channel. Events should only be sent once the channel is being listened to.

Returns: TRUE if successful.

Definition at line 196 of file fl_event_channel.cc.

                                                               {
  g_return_val_if_fail(FL_IS_EVENT_CHANNEL(self), FALSE);
  g_return_val_if_fail(event != nullptr, FALSE);
 
  g_autoptr(GBytes) data =
      fl_method_codec_encode_success_envelope(self->codec, event, error);
  if (data == nullptr) {
    return FALSE;
  }
 
  fl_binary_messenger_send_on_channel(self->messenger, self->name, data,
                                      cancellable, nullptr, nullptr);
 
  return TRUE;
}

References error, event, fl_binary_messenger_send_on_channel(), fl_method_codec_encode_success_envelope(), and TRUE.

Referenced by send_events_listen_cb().

fl_event_channel_send_end_of_stream()

G_MODULE_EXPORT gboolean fl_event_channel_send_end_of_stream	(	FlEventChannel *	self,
		GCancellable *	cancellable,
		GError **	error
	)

Definition at line 237 of file fl_event_channel.cc.

                    {
  g_return_val_if_fail(FL_IS_EVENT_CHANNEL(self), FALSE);
  fl_binary_messenger_send_on_channel(self->messenger, self->name, nullptr,
                                      cancellable, nullptr, nullptr);
  return TRUE;
}

References fl_binary_messenger_send_on_channel(), and TRUE.

fl_event_channel_send_error()

G_MODULE_EXPORT gboolean fl_event_channel_send_error	(	FlEventChannel *	self,
		const gchar *	code,
		const gchar *	message,
		FlValue *	details,
		GCancellable *	cancellable,
		GError **	error
	)

Definition at line 215 of file fl_event_channel.cc.

                                                                     {
  g_return_val_if_fail(FL_IS_EVENT_CHANNEL(self), FALSE);
  g_return_val_if_fail(code != nullptr, FALSE);
  g_return_val_if_fail(message != nullptr, FALSE);
 
  g_autoptr(GBytes) data = fl_method_codec_encode_error_envelope(
      self->codec, code, message, details, error);
  if (data == nullptr) {
    return FALSE;
  }
 
  fl_binary_messenger_send_on_channel(self->messenger, self->name, data,
                                      cancellable, nullptr, nullptr);
 
  return TRUE;
}

References error, fl_binary_messenger_send_on_channel(), fl_method_codec_encode_error_envelope(), and TRUE.

fl_event_channel_set_stream_handlers()

G_MODULE_EXPORT void fl_event_channel_set_stream_handlers	(	FlEventChannel *	channel,
		FlEventChannelHandler	listen_handler,
		FlEventChannelHandler	cancel_handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

fl_event_channel_set_stream_handlers: @channel: an #FlEventChannel. @listen_handler: (allow-none): function to call when the Dart side of the channel starts listening to the stream. @cancel_handler: (allow-none): function to call when the Dart side of the channel cancels their subscription to the stream. @user_data: (closure): user data to pass to @listen_handler and @cancel_handler. @destroy_notify: (allow-none): a function which gets called to free @user_data, or NULL.

Sets the functions called when the Dart side requests the stream to start and finish.

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

Definition at line 181 of file fl_event_channel.cc.

                                   {
  g_return_if_fail(FL_IS_EVENT_CHANNEL(self));
 
  remove_handlers(self);
  self->listen_handler = listen_handler;
  self->cancel_handler = cancel_handler;
  self->handler_data = user_data;
  self->handler_data_destroy_notify = destroy_notify;
}

References remove_handlers(), and user_data.

Referenced by TEST().

handle_method_call()

static FlMethodErrorResponse* handle_method_call ( FlEventChannel *  self, const gchar *  name, FlValue *  args  )

static

Definition at line 46 of file fl_event_channel.cc.

                                                                {
  FlEventChannelHandler handler;
  if (g_strcmp0(name, kListenMethod) == 0) {
    handler = self->listen_handler;
  } else if (g_strcmp0(name, kCancelMethod) == 0) {
    handler = self->cancel_handler;
  } else {
    g_autofree gchar* message =
        g_strdup_printf("Unknown event channel request '%s'", name);
    return fl_method_error_response_new(kEventRequestError, message, nullptr);
  }
 
  // If not handled, just accept requests.
  if (handler == nullptr) {
    return nullptr;
  }
 
  return handler(self, args, self->handler_data);
}

References args, fl_method_error_response_new(), kCancelMethod, kEventRequestError, and kListenMethod.

Referenced by message_cb().

message_cb()

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

static

Definition at line 69 of file fl_event_channel.cc.

                                           {
  FlEventChannel* self = FL_EVENT_CHANNEL(user_data);
 
  g_autofree gchar* name = nullptr;
  g_autoptr(GError) error = nullptr;
  g_autoptr(FlValue) args = nullptr;
  if (!fl_method_codec_decode_method_call(self->codec, message, &name, &args,
                                          &error)) {
    g_warning("Failed to decode message on event channel %s: %s", self->name,
              error->message);
    fl_binary_messenger_send_response(messenger, response_handle, nullptr,
                                      nullptr);
    return;
  }
 
  g_autoptr(FlMethodErrorResponse) response =
      handle_method_call(self, name, args);
 
  g_autoptr(GBytes) data = nullptr;
  if (response == nullptr) {
    g_autoptr(GError) codec_error = nullptr;
    data = fl_method_codec_encode_success_envelope(self->codec, nullptr,
                                                   &codec_error);
    if (data == nullptr) {
      g_warning("Failed to encode event channel %s success response: %s",
                self->name, codec_error->message);
    }
  } else {
    g_autoptr(GError) codec_error = nullptr;
    data = fl_method_codec_encode_error_envelope(
        self->codec, fl_method_error_response_get_code(response),
        fl_method_error_response_get_message(response),
        fl_method_error_response_get_details(response), &codec_error);
    if (data == nullptr) {
      g_warning("Failed to encode event channel %s error response: %s",
                self->name, codec_error->message);
    }
  }
 
  if (!fl_binary_messenger_send_response(messenger, response_handle, data,
                                         &error)) {
    g_warning("Failed to send event channel response: %s", error->message);
  }
}

References args, error, fl_binary_messenger_send_response(), fl_method_codec_decode_method_call(), fl_method_codec_encode_error_envelope(), fl_method_codec_encode_success_envelope(), fl_method_error_response_get_code(), fl_method_error_response_get_details(), fl_method_error_response_get_message(), handle_method_call(), and user_data.

Referenced by fl_event_channel_new().

remove_handlers()

static void remove_handlers ( FlEventChannel *  self )

static

Definition at line 119 of file fl_event_channel.cc.

                                                  {
  if (self->handler_data_destroy_notify != nullptr) {
    self->handler_data_destroy_notify(self->handler_data);
  }
  self->listen_handler = nullptr;
  self->cancel_handler = nullptr;
  self->handler_data = nullptr;
  self->handler_data_destroy_notify = nullptr;
}

Referenced by channel_closed_cb(), fl_event_channel_dispose(), and fl_event_channel_set_stream_handlers().

Variable Documentation

kCancelMethod

constexpr char kCancelMethod[] = "cancel"

staticconstexpr

Definition at line 12 of file fl_event_channel.cc.

Referenced by handle_method_call().

kEventRequestError

constexpr char kEventRequestError[] = "error"

staticconstexpr

Definition at line 13 of file fl_event_channel.cc.

Referenced by handle_method_call().

kListenMethod

constexpr char kListenMethod[] = "listen"

staticconstexpr

Definition at line 11 of file fl_event_channel.cc.

Referenced by handle_method_call().