Flutter Engine
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_MODULE_EXPORT GType fl_basic_message_channel_get_type ()
 
 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 FlValuefl_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 114 of file fl_basic_message_channel.cc.

References TRUE.

Referenced by fl_basic_message_channel_new().

114  {
115  g_autoptr(FlBasicMessageChannel) self = FL_BASIC_MESSAGE_CHANNEL(user_data);
116 
117  self->channel_closed = TRUE;
118 
119  // Disconnect handler.
120  if (self->message_handler_destroy_notify != nullptr) {
121  self->message_handler_destroy_notify(self->message_handler_data);
122  }
123  self->message_handler = nullptr;
124  self->message_handler_data = nullptr;
125  self->message_handler_destroy_notify = nullptr;
126 }
G_BEGIN_DECLS FlValue gpointer user_data
return TRUE
Definition: fl_view.cc:107

◆ fl_basic_message_channel_class_init()

static void fl_basic_message_channel_class_init ( FlBasicMessageChannelClass *  klass)
static

Definition at line 150 of file fl_basic_message_channel.cc.

References fl_basic_message_channel_dispose().

151  {
152  G_OBJECT_CLASS(klass)->dispose = fl_basic_message_channel_dispose;
153 }
static void fl_basic_message_channel_dispose(GObject *object)

◆ fl_basic_message_channel_dispose()

static void fl_basic_message_channel_dispose ( GObject *  object)
static

Definition at line 128 of file fl_basic_message_channel.cc.

References fl_binary_messenger_set_message_handler_on_channel().

Referenced by fl_basic_message_channel_class_init().

128  {
129  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(object);
130 
131  if (self->messenger != nullptr) {
133  self->messenger, self->name, nullptr, nullptr, nullptr);
134  }
135 
136  g_clear_object(&self->messenger);
137  g_clear_pointer(&self->name, g_free);
138  g_clear_object(&self->codec);
139 
140  if (self->message_handler_destroy_notify != nullptr) {
141  self->message_handler_destroy_notify(self->message_handler_data);
142  }
143  self->message_handler = nullptr;
144  self->message_handler_data = nullptr;
145  self->message_handler_destroy_notify = nullptr;
146 
147  G_OBJECT_CLASS(fl_basic_message_channel_parent_class)->dispose(object);
148 }
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)

◆ fl_basic_message_channel_get_type()

G_MODULE_EXPORT GType fl_basic_message_channel_get_type ( )

◆ fl_basic_message_channel_init()

static void fl_basic_message_channel_init ( FlBasicMessageChannel *  self)
static

Definition at line 155 of file fl_basic_message_channel.cc.

155 {}

◆ fl_basic_message_channel_new()

G_MODULE_EXPORT 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()

G_MODULE_EXPORT 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_response_handle_class_init()

static void fl_basic_message_channel_response_handle_class_init ( FlBasicMessageChannelResponseHandleClass *  klass)
static

Definition at line 54 of file fl_basic_message_channel.cc.

55  {
56  G_OBJECT_CLASS(klass)->dispose =
57  fl_basic_message_channel_response_handle_dispose;
58 }

◆ fl_basic_message_channel_response_handle_init()

static void fl_basic_message_channel_response_handle_init ( FlBasicMessageChannelResponseHandle *  self)
static

Definition at line 60 of file fl_basic_message_channel.cc.

61  {}

◆ fl_basic_message_channel_response_handle_new()

static FlBasicMessageChannelResponseHandle* fl_basic_message_channel_response_handle_new ( FlBinaryMessengerResponseHandle *  response_handle)
static

Definition at line 64 of file fl_basic_message_channel.cc.

Referenced by message_cb().

65  {
66  FlBasicMessageChannelResponseHandle* self =
67  FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(g_object_new(
68  fl_basic_message_channel_response_handle_get_type(), nullptr));
69 
70  self->response_handle =
71  FL_BINARY_MESSENGER_RESPONSE_HANDLE(g_object_ref(response_handle));
72 
73  return self;
74 }

◆ 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: : 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_BEGIN_DECLS FlValue gpointer user_data
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_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()

G_MODULE_EXPORT 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()

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: : 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 FlValue gpointer user_data

◆ G_DEFINE_TYPE()

G_DEFINE_TYPE ( FlBasicMessageChannelResponseHandle  ,
fl_basic_message_channel_response_handle  ,
G_TYPE_OBJECT   
)

Definition at line 40 of file fl_basic_message_channel.cc.

Referenced by G_DECLARE_FINAL_TYPE().

44  {
45  FlBasicMessageChannelResponseHandle* self =
46  FL_BASIC_MESSAGE_CHANNEL_RESPONSE_HANDLE(object);
47 
48  g_clear_object(&self->response_handle);
49 
50  G_OBJECT_CLASS(fl_basic_message_channel_response_handle_parent_class)
51  ->dispose(object);
52 }

◆ message_cb()

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

Definition at line 77 of file fl_basic_message_channel.cc.

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

Referenced by fl_basic_message_channel_new().

81  {
82  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(user_data);
83 
84  if (self->message_handler == nullptr) {
85  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
86  nullptr);
87  return;
88  }
89 
90  g_autoptr(GError) error = nullptr;
91  g_autoptr(FlValue) message_value =
92  fl_message_codec_decode_message(self->codec, message, &error);
93  if (message_value == nullptr) {
94  g_warning("Failed to decode message: %s", error->message);
95  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
96  nullptr);
97  }
98 
99  g_autoptr(FlBasicMessageChannelResponseHandle) handle =
101  self->message_handler(self, message_value, handle,
102  self->message_handler_data);
103 }
static FlBasicMessageChannelResponseHandle * fl_basic_message_channel_response_handle_new(FlBinaryMessengerResponseHandle *response_handle)
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:39
FlMethodResponse GError ** error
G_MODULE_EXPORT gboolean fl_binary_messenger_send_response(FlBinaryMessenger *self, FlBinaryMessengerResponseHandle *response_handle, GBytes *response, GError **error)
G_BEGIN_DECLS FlValue gpointer user_data
G_MODULE_EXPORT FlValue * fl_message_codec_decode_message(FlMessageCodec *self, GBytes *message, GError **error)

◆ message_response_cb()

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

Definition at line 106 of file fl_basic_message_channel.cc.

Referenced by fl_basic_message_channel_send().

108  {
109  GTask* task = G_TASK(user_data);
110  g_task_return_pointer(task, result, g_object_unref);
111 }
G_BEGIN_DECLS FlValue gpointer user_data