Flutter Linux Embedder
fl_basic_message_channel.cc File Reference

Go to the source code of this file.

Classes

struct  _FlBasicMessageChannel
 
struct  _FlBasicMessageChannelResponseHandle
 

Functions

 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 111 of file fl_basic_message_channel.cc.

111  {
112  g_autoptr(FlBasicMessageChannel) self = FL_BASIC_MESSAGE_CHANNEL(user_data);
113 
114  self->channel_closed = TRUE;
115 
116  // Disconnect handler.
117  if (self->message_handler_destroy_notify != nullptr) {
118  self->message_handler_destroy_notify(self->message_handler_data);
119  }
120  self->message_handler = nullptr;
121  self->message_handler_data = nullptr;
122  self->message_handler_destroy_notify = nullptr;
123 }

References TRUE, and user_data.

Referenced by fl_basic_message_channel_new().

◆ fl_basic_message_channel_class_init()

static void fl_basic_message_channel_class_init ( FlBasicMessageChannelClass *  klass)
static

Definition at line 147 of file fl_basic_message_channel.cc.

148  {
149  G_OBJECT_CLASS(klass)->dispose = fl_basic_message_channel_dispose;
150 }

References fl_basic_message_channel_dispose().

◆ fl_basic_message_channel_dispose()

static void fl_basic_message_channel_dispose ( GObject *  object)
static

Definition at line 125 of file fl_basic_message_channel.cc.

125  {
126  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(object);
127 
128  if (self->messenger != nullptr) {
130  self->messenger, self->name, nullptr, nullptr, nullptr);
131  }
132 
133  g_clear_object(&self->messenger);
134  g_clear_pointer(&self->name, g_free);
135  g_clear_object(&self->codec);
136 
137  if (self->message_handler_destroy_notify != nullptr) {
138  self->message_handler_destroy_notify(self->message_handler_data);
139  }
140  self->message_handler = nullptr;
141  self->message_handler_data = nullptr;
142  self->message_handler_destroy_notify = nullptr;
143 
144  G_OBJECT_CLASS(fl_basic_message_channel_parent_class)->dispose(object);
145 }

References fl_binary_messenger_set_message_handler_on_channel().

Referenced by fl_basic_message_channel_class_init().

◆ fl_basic_message_channel_init()

static void fl_basic_message_channel_init ( FlBasicMessageChannel *  self)
static

Definition at line 152 of file fl_basic_message_channel.cc.

152 {}

◆ fl_basic_message_channel_new()

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

Definition at line 154 of file fl_basic_message_channel.cc.

157  {
158  g_return_val_if_fail(FL_IS_BINARY_MESSENGER(messenger), nullptr);
159  g_return_val_if_fail(name != nullptr, nullptr);
160  g_return_val_if_fail(FL_IS_MESSAGE_CODEC(codec), nullptr);
161 
162  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(
163  g_object_new(fl_basic_message_channel_get_type(), nullptr));
164 
165  self->messenger = FL_BINARY_MESSENGER(g_object_ref(messenger));
166  self->name = g_strdup(name);
167  self->codec = FL_MESSAGE_CODEC(g_object_ref(codec));
168 
170  self->messenger, self->name, message_cb, g_object_ref(self),
172 
173  return self;
174 }

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

Referenced by fl_key_channel_responder_new(), fl_settings_plugin_new(), and TEST().

◆ 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: @channel: an #FlBasicMessageChannel. @response_handle: handle that was provided in a FlBasicMessageChannelMessageHandler. @message: (allow-none): message response to send or NULL for an empty response. @error: (allow-none): #GError location to store the error occurring, or NULL to ignore.

Responds to a message.

Returns: TRUE on success.

Definition at line 204 of file fl_basic_message_channel.cc.

208  {
209  g_return_val_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self), FALSE);
210  g_return_val_if_fail(response_handle != nullptr, FALSE);
211  g_return_val_if_fail(response_handle->response_handle != nullptr, FALSE);
212 
213  g_autoptr(GBytes) data =
214  fl_message_codec_encode_message(self->codec, message, error);
215  if (data == nullptr) {
216  return FALSE;
217  }
218 
220  self->messenger, response_handle->response_handle, data, error);
221  g_clear_object(&response_handle->response_handle);
222 
223  return result;
224 }

References error, fl_binary_messenger_send_response(), fl_message_codec_encode_message(), and result.

Referenced by message_cb(), and response_cb().

◆ fl_basic_message_channel_response_handle_class_init()

static void fl_basic_message_channel_response_handle_class_init ( FlBasicMessageChannelResponseHandleClass *  klass)
static

Definition at line 51 of file fl_basic_message_channel.cc.

52  {
53  G_OBJECT_CLASS(klass)->dispose =
54  fl_basic_message_channel_response_handle_dispose;
55 }

◆ fl_basic_message_channel_response_handle_init()

static void fl_basic_message_channel_response_handle_init ( FlBasicMessageChannelResponseHandle *  self)
static

Definition at line 57 of file fl_basic_message_channel.cc.

58  {}

◆ fl_basic_message_channel_response_handle_new()

static FlBasicMessageChannelResponseHandle* fl_basic_message_channel_response_handle_new ( FlBinaryMessengerResponseHandle *  response_handle)
static

Definition at line 61 of file fl_basic_message_channel.cc.

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

Referenced by message_cb().

◆ 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: @channel: an #FlBasicMessageChannel. @message: (allow-none): message to send, must match what the #FlMessageCodec 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.

Asynchronously sends a message.

Definition at line 226 of file fl_basic_message_channel.cc.

230  {
231  g_return_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self));
232 
233  g_autoptr(GTask) task =
234  callback != nullptr ? g_task_new(self, cancellable, callback, user_data)
235  : nullptr;
236 
237  g_autoptr(GError) error = nullptr;
238  g_autoptr(GBytes) data =
239  fl_message_codec_encode_message(self->codec, message, &error);
240  if (data == nullptr) {
241  if (task != nullptr) {
242  g_task_return_error(task, error);
243  }
244  return;
245  }
246 
248  self->messenger, self->name, data, cancellable,
249  callback != nullptr ? message_response_cb : nullptr,
250  g_steal_pointer(&task));
251 }

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

Referenced by fl_key_channel_responder_handle_event(), TEST(), and update_settings().

◆ 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: @channel: an #FlBasicMessageChannel.

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

256  {
257  g_return_val_if_fail(FL_IS_BASIC_MESSAGE_CHANNEL(self), nullptr);
258  g_return_val_if_fail(g_task_is_valid(result, self), nullptr);
259 
260  g_autoptr(GTask) task = G_TASK(result);
261  GAsyncResult* r = G_ASYNC_RESULT(g_task_propagate_pointer(task, nullptr));
262 
263  g_autoptr(GBytes) message =
265  if (message == nullptr) {
266  return nullptr;
267  }
268 
269  return fl_message_codec_decode_message(self->codec, message, error);
270 }

References error, fl_binary_messenger_send_on_channel_finish(), fl_message_codec_decode_message(), and result.

Referenced by echo_response_cb(), failure_response_cb(), handle_response(), and null_message_response_cb().

◆ 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: @channel: an #FlBasicMessageChannel. @handler: (allow-none): function to call when a message is received on this channel or NULL to disable the handler. @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 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 @destroy_notify if you want to detect this.

Definition at line 176 of file fl_basic_message_channel.cc.

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

References user_data.

Referenced by TEST().

◆ G_DEFINE_TYPE()

G_DEFINE_TYPE ( FlBasicMessageChannelResponseHandle  ,
fl_basic_message_channel_response_handle  ,
G_TYPE_OBJECT   
)

Definition at line 37 of file fl_basic_message_channel.cc.

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

◆ message_cb()

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

Definition at line 74 of file fl_basic_message_channel.cc.

78  {
79  FlBasicMessageChannel* self = FL_BASIC_MESSAGE_CHANNEL(user_data);
80 
81  if (self->message_handler == nullptr) {
82  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
83  nullptr);
84  return;
85  }
86 
87  g_autoptr(GError) error = nullptr;
88  g_autoptr(FlValue) message_value =
89  fl_message_codec_decode_message(self->codec, message, &error);
90  if (message_value == nullptr) {
91  g_warning("Failed to decode message: %s", error->message);
92  fl_binary_messenger_send_response(messenger, response_handle, nullptr,
93  nullptr);
94  }
95 
96  g_autoptr(FlBasicMessageChannelResponseHandle) handle =
98  self->message_handler(self, message_value, handle,
99  self->message_handler_data);
100 }

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

Referenced by fl_basic_message_channel_new().

◆ message_response_cb()

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

Definition at line 103 of file fl_basic_message_channel.cc.

105  {
106  GTask* task = G_TASK(user_data);
107  g_task_return_pointer(task, result, g_object_unref);
108 }

References result, and user_data.

Referenced by fl_basic_message_channel_send().

channel_closed_cb
static void channel_closed_cb(gpointer user_data)
Definition: fl_basic_message_channel.cc:111
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42
user_data
FlKeyEvent uint64_t FlKeyResponderAsyncCallback gpointer user_data
Definition: fl_key_channel_responder.cc:121
message_response_cb
static void message_response_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_basic_message_channel.cc:103
message_cb
static void message_cb(FlBinaryMessenger *messenger, const gchar *channel, GBytes *message, FlBinaryMessengerResponseHandle *response_handle, gpointer user_data)
Definition: fl_basic_message_channel.cc:74
fl_message_codec_decode_message
G_MODULE_EXPORT FlValue * fl_message_codec_decode_message(FlMessageCodec *self, GBytes *message, GError **error)
Definition: fl_message_codec.cc:33
fl_binary_messenger_set_message_handler_on_channel
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)
Definition: fl_binary_messenger.cc:424
TRUE
return TRUE
Definition: fl_pixel_buffer_texture_test.cc:53
fl_binary_messenger_send_on_channel_finish
G_MODULE_EXPORT GBytes * fl_binary_messenger_send_on_channel_finish(FlBinaryMessenger *self, GAsyncResult *result, GError **error)
Definition: fl_binary_messenger.cc:465
fl_basic_message_channel_response_handle_new
static FlBasicMessageChannelResponseHandle * fl_basic_message_channel_response_handle_new(FlBinaryMessengerResponseHandle *response_handle)
Definition: fl_basic_message_channel.cc:61
result
GAsyncResult * result
Definition: fl_text_input_plugin.cc:106
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40
fl_message_codec_encode_message
G_MODULE_EXPORT GBytes * fl_message_codec_encode_message(FlMessageCodec *self, FlValue *message, GError **error)
Definition: fl_message_codec.cc:17
callback
FlKeyEvent uint64_t FlKeyResponderAsyncCallback callback
Definition: fl_key_channel_responder.cc:120
fl_binary_messenger_send_response
G_MODULE_EXPORT gboolean fl_binary_messenger_send_response(FlBinaryMessenger *self, FlBinaryMessengerResponseHandle *response_handle, GBytes *response, GError **error)
Definition: fl_binary_messenger.cc:438
fl_binary_messenger_send_on_channel
G_MODULE_EXPORT void fl_binary_messenger_send_on_channel(FlBinaryMessenger *self, const gchar *channel, GBytes *message, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
Definition: fl_binary_messenger.cc:451
fl_basic_message_channel_dispose
static void fl_basic_message_channel_dispose(GObject *object)
Definition: fl_basic_message_channel.cc:125