Flutter Engine
fl_basic_message_channel.h File Reference
#include <gio/gio.h>
#include <glib-object.h>
#include "fl_binary_messenger.h"
#include "fl_message_codec.h"

Go to the source code of this file.

Functions

G_BEGIN_DECLS G_DECLARE_FINAL_TYPE (FlBasicMessageChannel, fl_basic_message_channel, FL, BASIC_MESSAGE_CHANNEL, GObject) G_DECLARE_FINAL_TYPE(FlBasicMessageChannelResponseHandle
 
: a channel name.

fl_basic_message_channel_new: : an #FlBinaryMessenger.

: the message codec.

Creates a basic message channel. must match the codec used on the Dart end of the channel.

Returns: a new #FlBasicMessageChannel.

FlBasicMessageChannel * fl_basic_message_channel_new (FlBinaryMessenger *messenger, const gchar *name, FlMessageCodec *codec)
 
void fl_basic_message_channel_set_message_handler (FlBasicMessageChannel *channel, FlBasicMessageChannelMessageHandler handler, gpointer user_data, GDestroyNotify destroy_notify)
 
gboolean fl_basic_message_channel_respond (FlBasicMessageChannel *channel, FlBasicMessageChannelResponseHandle *response_handle, FlValue *message, GError **error)
 
void fl_basic_message_channel_send (FlBasicMessageChannel *channel, FlValue *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
 
FlValuefl_basic_message_channel_send_finish (FlBasicMessageChannel *channel, GAsyncResult *result, GError **error)
 

Variables

G_BEGIN_DECLS GObject typedef void(* FlBasicMessageChannelMessageHandler )(FlBasicMessageChannel *channel, FlValue *message, FlBasicMessageChannelResponseHandle *response_handle, gpointer user_data)
 
G_BEGIN_DECLS fl_basic_message_channel_response_handle
 
G_BEGIN_DECLS FL
 
G_BEGIN_DECLS BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE
 

Function Documentation

◆ fl_basic_message_channel_new()

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

Definition at line 157 of file fl_basic_message_channel.cc.

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

Referenced by fl_key_event_plugin_new(), and TEST().

160  {
161  g_return_val_if_fail(FL_IS_BINARY_MESSENGER(messenger), nullptr);
162  g_return_val_if_fail(name != nullptr, nullptr);
163  g_return_val_if_fail(FL_IS_MESSAGE_CODEC(codec), nullptr);
164 
165  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(
166  g_object_new(fl_basic_message_channel_get_type(), nullptr));
167 
168  self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger));
169  self->name = g_strdup(name);
170  self->codec = FL_MESSAGE_CODEC(g_object_ref(codec));
171 
173  self->messenger, self->name, message_cb, g_object_ref(self),
175 
176  return self;
177 }
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 GType fl_basic_message_channel_get_type()
static void channel_closed_cb(gpointer user_data)
const char * name
Definition: fuchsia.cc:50
static void message_cb(FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)

◆ fl_basic_message_channel_respond()

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

fl_basic_message_channel_respond: : an #FlBasicMessageChannel. : handle that was provided in a FlBasicMessageChannelMessageHandler. : (allow-none): message response to send or NULL for an empty response. : (allow-none): #GError location to store the error occurring, or NULL to ignore.

Responds to a message.

Returns: TRUE on success.

Definition at line 207 of file fl_basic_message_channel.cc.

References fl_binary_messenger_send_response(), and fl_message_codec_encode_message().

Referenced by message_cb(), and response_cb().

211  {
212  g_return_val_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self), FALSE);
213  g_return_val_if_fail(response_handle != nullptr, FALSE);
214  g_return_val_if_fail(response_handle->response_handle != nullptr, FALSE);
215 
216  g_autoptr(GBytes) data =
217  fl_message_codec_encode_message(self->codec, message, error);
218  if (data == nullptr) {
219  return FALSE;
220  }
221 
222  gboolean result = fl_binary_messenger_send_response(
223  self->messenger, response_handle->response_handle, data, error);
224  g_clear_object(&response_handle->response_handle);
225 
226  return result;
227 }
FlMethodResponse GError ** error
G_MODULE_EXPORT gboolean fl_binary_messenger_send_response(FlBinaryMessenger *self, FlBinaryMessengerResponseHandle *response_handle, GBytes *response, GError **error)
G_MODULE_EXPORT GBytes * fl_message_codec_encode_message(FlMessageCodec *self, FlValue *message, GError **error)

◆ fl_basic_message_channel_send()

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

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

Asynchronously sends a message.

Definition at line 229 of file fl_basic_message_channel.cc.

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

Referenced by fl_key_event_plugin_send_key_event(), and TEST().

233  {
234  g_return_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self));
235  g_return_if_fail(message != nullptr);
236 
237  g_autoptr(GTask) task =
238  callback != nullptr ? g_task_new(self, cancellable, callback, user_data)
239  : nullptr;
240 
241  g_autoptr(GError) error = nullptr;
242  g_autoptr(GBytes) data =
243  fl_message_codec_encode_message(self->codec, message, &error);
244  if (data == nullptr) {
245  if (task != nullptr) {
246  g_task_return_error(task, error);
247  }
248  return;
249  }
250 
252  self->messenger, self->name, data, cancellable,
253  callback != nullptr ? message_response_cb : nullptr,
254  g_steal_pointer(&task));
255 }
FlMethodResponse 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_BEGIN_DECLS FlMethodCall gpointer user_data
G_MODULE_EXPORT GBytes * fl_message_codec_encode_message(FlMessageCodec *self, FlValue *message, GError **error)
static void message_response_cb(GObject *object, GAsyncResult *result, gpointer user_data)

◆ fl_basic_message_channel_send_finish()

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

fl_basic_message_channel_send_finish: : an #FlBasicMessageChannel.

Returns
: a #GAsyncResult. : (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 257 of file fl_basic_message_channel.cc.

References fl_binary_messenger_send_on_channel_finish(), and fl_message_codec_decode_message().

Referenced by echo_response_cb(), and failure_response_cb().

260  {
261  g_return_val_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self), nullptr);
262  g_return_val_if_fail(g_task_is_valid(result, self), nullptr);
263 
264  g_autoptr(GTask) task = G_TASK(result);
265  GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr));
266 
267  g_autoptr(GBytes) message =
269  if (message == nullptr) {
270  return nullptr;
271  }
272 
273  return fl_message_codec_decode_message(self->codec, message, error);
274 }
FlMethodResponse GError ** error
G_MODULE_EXPORT GBytes * fl_binary_messenger_send_on_channel_finish(FlBinaryMessenger *self, GAsyncResult *result, GError **error)
G_MODULE_EXPORT FlValue * fl_message_codec_decode_message(FlMessageCodec *self, GBytes *message, GError **error)

◆ fl_basic_message_channel_set_message_handler()

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: : an #FlBasicMessageChannel. : (allow-none): function to call when a message is received on this channel or NULL to disable the handler. : (closure): user data to pass to . : (allow-none): a function which gets called to free , 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 if you want to detect this.

Definition at line 179 of file fl_basic_message_channel.cc.

References user_data.

Referenced by TEST().

183  {
184  g_return_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self));
185 
186  // Don't set handler if channel closed.
187  if (self->channel_closed) {
188  if (handler != nullptr) {
189  g_warning(
190  "Attempted to set message handler on a closed FlBasicMessageChannel");
191  }
192  if (destroy_notify != nullptr) {
193  destroy_notify(user_data);
194  }
195  return;
196  }
197 
198  if (self->message_handler_destroy_notify != nullptr) {
199  self->message_handler_destroy_notify(self->message_handler_data);
200  }
201 
202  self->message_handler = handler;
203  self->message_handler_data = user_data;
204  self->message_handler_destroy_notify = destroy_notify;
205 }
G_BEGIN_DECLS FlMethodCall gpointer user_data

◆ G_DECLARE_FINAL_TYPE()

G_BEGIN_DECLS G_DECLARE_FINAL_TYPE ( FlBasicMessageChannel  ,
fl_basic_message_channel  ,
FL  ,
BASIC_MESSAGE_CHANNEL  ,
GObject   
)

Variable Documentation

◆ BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE

G_BEGIN_DECLS BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE

Definition at line 27 of file fl_basic_message_channel.h.

◆ FL

G_BEGIN_DECLS FL

Definition at line 27 of file fl_basic_message_channel.h.

◆ fl_basic_message_channel_response_handle

G_BEGIN_DECLS fl_basic_message_channel_response_handle

Definition at line 27 of file fl_basic_message_channel.h.

◆ FlBasicMessageChannelMessageHandler

G_BEGIN_DECLS GObject typedef void(* FlBasicMessageChannelMessageHandler) (FlBasicMessageChannel *channel, FlValue *message, FlBasicMessageChannelResponseHandle *response_handle, gpointer user_data)

FlBasicMessageChannel:

#FlBasicMessageChannel is an object that allows sending and receiving messages to/from Dart code over platform channels.

The following example shows how to send messages on a channel:

|[ static FlBasicMessageChannel *channel = NULL;

static void message_cb (FlBasicMessageChannel* channel, FlValue* message, FlBasicMessageChannelResponseHandle* response_handle, gpointer user_data) { g_autoptr(FlValue) response = handle_message (message); g_autoptr(GError) error = NULL; if (!fl_basic_message_channel_respond (channel, response_handle, response, &error)) g_warning ("Failed to send channel response: %s", error->message); }

static void message_response_cb (GObject *object, GAsyncResult *result, gpointer user_data) { g_autoptr(GError) error = NULL; g_autoptr(FlValue) response = fl_basic_message_channel_send_finish (FL_BASIC_MESSAGE_CHANNEL (object), result, &error); if (response == NULL) { g_warning ("Failed to send message: %s", error->message); return; }

handle_response (response); }

static void setup_channel () { g_autoptr(FlStandardMessageCodec) codec = fl_standard_message_codec_new (); channel = fl_basic_message_channel_new (messenger, "flutter/foo", FL_MESSAGE_CODEC (codec)); fl_basic_message_channel_set_message_handler (channel, message_cb, NULL, NULL);

g_autoptr(FlValue) message = fl_value_new_string ("Hello World"); fl_basic_message_channel_send (channel, message, NULL, message_response_cb, NULL); } ]|

#FlBasicMessageChannel matches the BasicMessageChannel class in the Flutter services library. FlBasicMessageChannelResponseHandle:

#FlBasicMessageChannelResponseHandle is an object used to send responses with. FlBasicMessageChannelMessageHandler: : an #FlBasicMessageChannel. : message received. : a handle to respond to the message with. : (closure): data provided when registering this handler.

Function called when a message is received. Call fl_basic_message_channel_respond() to respond to this message. If the response is not occurring in this callback take a reference to and release that once it has been responded to. Failing to respond before the last reference to is dropped is a programming error.

Definition at line 107 of file fl_basic_message_channel.h.