fl_method_channel.cc File Reference

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

Go to the source code of this file.

Classes
struct	_FlMethodChannel

Functions
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_method_channel_dispose (GObject *object)
static void	fl_method_channel_class_init (FlMethodChannelClass *klass)
static void	fl_method_channel_init (FlMethodChannel *self)
G_MODULE_EXPORT FlMethodChannel *	fl_method_channel_new (FlBinaryMessenger *messenger, const gchar *name, FlMethodCodec *codec)
G_MODULE_EXPORT void	fl_method_channel_set_method_call_handler (FlMethodChannel *self, FlMethodChannelMethodCallHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
G_MODULE_EXPORT void	fl_method_channel_invoke_method (FlMethodChannel *self, const gchar *method, FlValue *args, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
G_MODULE_EXPORT FlMethodResponse *	fl_method_channel_invoke_method_finish (FlMethodChannel *self, GAsyncResult *result, GError **error)
gboolean	fl_method_channel_respond (FlMethodChannel *self, FlBinaryMessengerResponseHandle *response_handle, FlMethodResponse *response, GError **error)

Function Documentation

channel_closed_cb()

static void channel_closed_cb ( gpointer  user_data )

static

Definition at line 71 of file fl_method_channel.cc.

                                                  {
  g_autoptr(FlMethodChannel) self = FL_METHOD_CHANNEL(user_data);
 
  self->channel_closed = TRUE;
 
  // Disconnect handler.
  if (self->method_call_handler_destroy_notify != nullptr) {
    self->method_call_handler_destroy_notify(self->method_call_handler_data);
  }
  self->method_call_handler = nullptr;
  self->method_call_handler_data = nullptr;
  self->method_call_handler_destroy_notify = nullptr;
}

fl_method_channel_class_init()

static void fl_method_channel_class_init ( FlMethodChannelClass *  klass )

static

Definition at line 106 of file fl_method_channel.cc.

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

fl_method_channel_dispose()

static void fl_method_channel_dispose ( GObject *  object )

static

Definition at line 85 of file fl_method_channel.cc.

                                                       {
  FlMethodChannel* self = FL_METHOD_CHANNEL(object);
 
  // Note we don't have to clear the handler in messenger as it holds
  // a reference to this object so the following code is only run after
  // the messenger has closed the channel already.
 
  g_clear_object(&self->messenger);
  g_clear_pointer(&self->name, g_free);
  g_clear_object(&self->codec);
 
  if (self->method_call_handler_destroy_notify != nullptr) {
    self->method_call_handler_destroy_notify(self->method_call_handler_data);
  }
  self->method_call_handler = nullptr;
  self->method_call_handler_data = nullptr;
  self->method_call_handler_destroy_notify = nullptr;
 
  G_OBJECT_CLASS(fl_method_channel_parent_class)->dispose(object);
}

fl_method_channel_init()

static void fl_method_channel_init ( FlMethodChannel *  self )

static

Definition at line 110 of file fl_method_channel.cc.

{}

fl_method_channel_invoke_method()

G_MODULE_EXPORT void fl_method_channel_invoke_method	(	FlMethodChannel *	channel,
		const gchar *	method,
		FlValue *	args,
		GCancellable *	cancellable,
		GAsyncReadyCallback	callback,
		gpointer	user_data
	)

fl_method_channel_invoke_method: @channel: an #FlMethodChannel. @method: the method to call. @args: (allow-none): arguments to the method, must match what the #FlMethodCodec 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.

Calls a method on this channel.

Definition at line 162 of file fl_method_channel.cc.

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

fl_method_channel_invoke_method_finish()

G_MODULE_EXPORT FlMethodResponse * fl_method_channel_invoke_method_finish	(	FlMethodChannel *	channel,
		GAsyncResult *	result,
		GError **	error
	)

fl_method_channel_invoke_method_finish: @channel: an #FlMethodChannel.

Returns

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

Completes request started with fl_method_channel_invoke_method().

Returns: (transfer full): an #FlMethodResponse or NULL on error.

Definition at line 192 of file fl_method_channel.cc.

                    {
  g_return_val_if_fail(FL_IS_METHOD_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) response =
      fl_binary_messenger_send_on_channel_finish(self->messenger, r, error);
  if (response == nullptr) {
    return nullptr;
  }
 
  return fl_method_codec_decode_response(self->codec, response, error);
}

fl_method_channel_new()

G_MODULE_EXPORT FlMethodChannel * fl_method_channel_new	(	FlBinaryMessenger *	messenger,
		const gchar *	name,
		FlMethodCodec *	codec
	)

Definition at line 112 of file fl_method_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);
 
  FlMethodChannel* self =
      FL_METHOD_CHANNEL(g_object_new(fl_method_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_method_channel_respond()

gboolean fl_method_channel_respond	(	FlMethodChannel *	channel,
		FlBinaryMessengerResponseHandle *	response_handle,
		FlMethodResponse *	response,
		GError **	error
	)

fl_method_channel_respond: @channel: an #FlMethodChannel. @response_handle: an #FlBinaryMessengerResponseHandle. @response: an #FlMethodResponse. @error: (allow-none): #GError location to store the error occurring, or NULL to ignore.

Responds to a method call.

Returns: TRUE on success.

Definition at line 211 of file fl_method_channel.cc.

                    {
  g_return_val_if_fail(FL_IS_METHOD_CHANNEL(self), FALSE);
  g_return_val_if_fail(FL_IS_BINARY_MESSENGER_RESPONSE_HANDLE(response_handle),
                       FALSE);
  g_return_val_if_fail(FL_IS_METHOD_SUCCESS_RESPONSE(response) ||
                           FL_IS_METHOD_ERROR_RESPONSE(response) ||
                           FL_IS_METHOD_NOT_IMPLEMENTED_RESPONSE(response),
                       FALSE);
 
  g_autoptr(GBytes) message = nullptr;
  if (FL_IS_METHOD_SUCCESS_RESPONSE(response)) {
    FlMethodSuccessResponse* r = FL_METHOD_SUCCESS_RESPONSE(response);
    message = fl_method_codec_encode_success_envelope(
        self->codec, fl_method_success_response_get_result(r), error);
    if (message == nullptr) {
      return FALSE;
    }
  } else if (FL_IS_METHOD_ERROR_RESPONSE(response)) {
    FlMethodErrorResponse* r = FL_METHOD_ERROR_RESPONSE(response);
    message = fl_method_codec_encode_error_envelope(
        self->codec, fl_method_error_response_get_code(r),
        fl_method_error_response_get_message(r),
        fl_method_error_response_get_details(r), error);
    if (message == nullptr) {
      return FALSE;
    }
  } else if (FL_IS_METHOD_NOT_IMPLEMENTED_RESPONSE(response)) {
    message = nullptr;
  } else {
    g_assert_not_reached();
  }
 
  return fl_binary_messenger_send_response(self->messenger, response_handle,
                                           message, error);
}

fl_method_channel_set_method_call_handler()

G_MODULE_EXPORT void fl_method_channel_set_method_call_handler	(	FlMethodChannel *	channel,
		FlMethodChannelMethodCallHandler	handler,
		gpointer	user_data,
		GDestroyNotify	destroy_notify
	)

fl_method_channel_set_method_call_handler: @channel: an #FlMethodChannel. @handler: function to call when a method call is received on this channel. @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 method call is received from the Dart side of the channel. See #FlMethodChannelMethodCallHandler for details on how to respond to method calls.

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 134 of file fl_method_channel.cc.

                                   {
  g_return_if_fail(FL_IS_METHOD_CHANNEL(self));
 
  // Don't set handler if channel closed.
  if (self->channel_closed) {
    if (handler != nullptr) {
      g_warning(
          "Attempted to set method call handler on a closed FlMethodChannel");
    }
    if (destroy_notify != nullptr) {
      destroy_notify(user_data);
    }
    return;
  }
 
  if (self->method_call_handler_destroy_notify != nullptr) {
    self->method_call_handler_destroy_notify(self->method_call_handler_data);
  }
 
  self->method_call_handler = handler;
  self->method_call_handler_data = user_data;
  self->method_call_handler_destroy_notify = destroy_notify;
}

message_cb()

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

static

Definition at line 37 of file fl_method_channel.cc.

                                           {
  FlMethodChannel* self = FL_METHOD_CHANNEL(user_data);
 
  if (self->method_call_handler == nullptr) {
    return;
  }
 
  g_autofree gchar* method = nullptr;
  g_autoptr(FlValue) args = nullptr;
  g_autoptr(GError) error = nullptr;
  if (!fl_method_codec_decode_method_call(self->codec, message, &method, &args,
                                          &error)) {
    g_warning("Failed to decode method call: %s", error->message);
    return;
  }
 
  g_autoptr(FlMethodCall) method_call =
      fl_method_call_new(method, args, self, response_handle);
  self->method_call_handler(self, method_call, self->method_call_handler_data);
}

message_response_cb()

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

static

Definition at line 63 of file fl_method_channel.cc.

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