| Flutter Linux Embedder |

Classes | Functions
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_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 FlValue * | fl_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 }
g_autoptr
g_autoptr(FlEngine) engine
user_data
const char FlTextDirection FlAssertiveness gpointer user_data
Definition: fl_accessibility_handler.cc:24
TRUE
return TRUE
Definition: fl_compositor_software.cc:68

References g_autoptr(), 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 }
fl_basic_message_channel_dispose
static void fl_basic_message_channel_dispose(GObject *object)
Definition: fl_basic_message_channel.cc:125

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) {
129 fl_binary_messenger_set_message_handler_on_channel(
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 }
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:408

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
169 fl_binary_messenger_set_message_handler_on_channel(
170 self->messenger, self->name, message_cb, g_object_ref(self),
171 channel_closed_cb);
172
173 return self;
174 }
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
channel_closed_cb
static void channel_closed_cb(gpointer user_data)
Definition: fl_basic_message_channel.cc:111

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

Referenced by fl_accessibility_channel_new(), fl_key_event_channel_new(), fl_settings_channel_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. If `error` is not NULL, `*error` must be initialized (typically NULL, but an error from a previous call using GLib error handling is explicitly valid).

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
219 gboolean result = fl_binary_messenger_send_response(
220 self->messenger, response_handle->response_handle, data, error);
221 g_clear_object(&response_handle->response_handle);
222
223 return result;
224 }
message
const char * message
Definition: fl_accessibility_handler.cc:21
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:422
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
error
const uint8_t uint32_t uint32_t GError ** error
Definition: fl_pixel_buffer_texture_test.cc:40

References error, fl_binary_messenger_send_response(), fl_message_codec_encode_message(), g_autoptr(), and message.

Referenced by message_cb(), and TEST().

## ◆ 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, g_error_copy(error));
243 }
244 return;
245 }
246
247 fl_binary_messenger_send_on_channel(
248 self->messenger, self->name, data, cancellable,
249 callback != nullptr ? message_response_cb : nullptr,
250 g_steal_pointer(&task));
251 }
message_response_cb
static void message_response_cb(GObject *object, GAsyncResult *result, gpointer user_data)
Definition: fl_basic_message_channel.cc:103
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:435

References error, fl_binary_messenger_send_on_channel(), fl_message_codec_encode_message(), g_autoptr(), message, message_response_cb(), and user_data.

Referenced by fl_key_event_channel_send(), fl_settings_channel_send(), and TEST().

## ◆ 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. If `error` is not NULL, `*error` must be initialized (typically NULL, but an error from a previous call using GLib error handling is explicitly valid).

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 GTask* task = G_TASK(result);
261 g_autoptr(GAsyncResult) r =
262 G_ASYNC_RESULT(g_task_propagate_pointer(task, error));
263 if (r == nullptr) {
264 return nullptr;
265 }
266
267 g_autoptr(GBytes) message =
268 fl_binary_messenger_send_on_channel_finish(self->messenger, r, error);
269 if (message == nullptr) {
270 return nullptr;
271 }
272
273 return fl_message_codec_decode_message(self->codec, message, error);
274 }
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:449
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

References error, fl_binary_messenger_send_on_channel_finish(), fl_message_codec_decode_message(), g_autoptr(), and message.

Referenced by fl_key_event_channel_send_finish(), and TEST().

## ◆ 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 fl_accessibility_channel_new(), and 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 =
97 fl_basic_message_channel_response_handle_new(response_handle);
98 self->message_handler(self, message_value, handle,
99 self->message_handler_data);
100 }
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
FlValue
typedefG_BEGIN_DECLS struct _FlValue FlValue
Definition: fl_value.h:42

References error, fl_basic_message_channel_response_handle_new(), fl_binary_messenger_send_response(), fl_message_codec_decode_message(), g_autoptr(), 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 g_autoptr(GTask) task = G_TASK(user_data);
107 g_task_return_pointer(task, g_object_ref(result), g_object_unref);
108 }

References g_autoptr(), and user_data.

Referenced by fl_basic_message_channel_send().