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);
}

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;
}

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);
}

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;
}

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;
}

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;
}

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;
}

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;
}

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);
}

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);
  }
}

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;
}

Variable Documentation

kCancelMethod

constexpr char kCancelMethod[] = "cancel"

staticconstexpr

Definition at line 12 of file fl_event_channel.cc.

kEventRequestError

constexpr char kEventRequestError[] = "error"

staticconstexpr

Definition at line 13 of file fl_event_channel.cc.

kListenMethod

constexpr char kListenMethod[] = "listen"

staticconstexpr

Definition at line 11 of file fl_event_channel.cc.