Debian Codegraph @

lib/wp/event-hook.c

raw
1 /* WirePlumber
2 *
3 * Copyright © 2022 Collabora Ltd.
4 * @author George Kiagiadakis <[email protected]>
5 *
6 * SPDX-License-Identifier: MIT
7 */
8
9 #include "event-hook.h"
10 #include "event-dispatcher.h"
11 #include "transition.h"
12 #include "log.h"
13 #include "wpenums.h"
14
15 WP_DEFINE_LOCAL_LOG_TOPIC ("wp-event-hook")
16
17 typedef struct _WpEventHookPrivate WpEventHookPrivate;
18 struct _WpEventHookPrivate
19 {
20 GWeakRef dispatcher;
21 gchar *name;
22 gchar **before;
23 gchar **after;
24 };
25
26 enum {
27 PROP_0,
28 PROP_NAME,
29 PROP_RUNS_BEFORE_HOOKS,
30 PROP_RUNS_AFTER_HOOKS,
31 PROP_DISPATCHER,
32 };
33
34 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (WpEventHook, wp_event_hook, G_TYPE_OBJECT)
35
36 static void
37 wp_event_hook_init (WpEventHook * self)
38 {
39 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
40 g_weak_ref_init (&priv->dispatcher, NULL);
41 }
42
43 static void
44 wp_event_hook_finalize (GObject * object)
45 {
46 WpEventHook *self = WP_EVENT_HOOK (object);
47 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
48
49 g_weak_ref_clear (&priv->dispatcher);
50 g_strfreev (priv->before);
51 g_strfreev (priv->after);
52 g_free (priv->name);
53
54 G_OBJECT_CLASS (wp_event_hook_parent_class)->finalize (object);
55 }
56
57 static void
58 wp_event_hook_set_property (GObject * object, guint property_id,
59 const GValue * value, GParamSpec * pspec)
60 {
61 WpEventHook *self = WP_EVENT_HOOK (object);
62 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
63
64 switch (property_id) {
65 case PROP_NAME:
66 priv->name = g_value_dup_string (value);
67 break;
68 case PROP_RUNS_BEFORE_HOOKS:
69 priv->before = g_value_dup_boxed (value);
70 break;
71 case PROP_RUNS_AFTER_HOOKS:
72 priv->after = g_value_dup_boxed (value);
73 break;
74 default:
75 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
76 break;
77 }
78 }
79
80 static void
81 wp_event_hook_get_property (GObject * object, guint property_id, GValue * value,
82 GParamSpec * pspec)
83 {
84 WpEventHook *self = WP_EVENT_HOOK (object);
85 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
86
87 switch (property_id) {
88 case PROP_NAME:
89 g_value_set_string (value, priv->name);
90 break;
91 case PROP_RUNS_BEFORE_HOOKS:
92 g_value_set_boxed (value, priv->before);
93 break;
94 case PROP_RUNS_AFTER_HOOKS:
95 g_value_set_boxed (value, priv->after);
96 break;
97 case PROP_DISPATCHER:
98 g_value_take_object (value, wp_event_hook_get_dispatcher (self));
99 break;
100 default:
101 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
102 break;
103 }
104 }
105
106 static void
107 wp_event_hook_class_init (WpEventHookClass * klass)
108 {
109 GObjectClass *object_class = (GObjectClass *) klass;
110
111 object_class->finalize = wp_event_hook_finalize;
112 object_class->set_property = wp_event_hook_set_property;
113 object_class->get_property = wp_event_hook_get_property;
114
115 g_object_class_install_property (object_class, PROP_NAME,
116 g_param_spec_string ("name", "name", "The hook name", "",
117 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
118
119 g_object_class_install_property (object_class, PROP_RUNS_BEFORE_HOOKS,
120 g_param_spec_boxed ("runs-before-hooks", "runs-before-hooks",
121 "runs-before-hooks", G_TYPE_STRV,
122 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
123
124 g_object_class_install_property (object_class, PROP_RUNS_AFTER_HOOKS,
125 g_param_spec_boxed ("runs-after-hooks", "runs-after-hooks",
126 "runs-after-hooks", G_TYPE_STRV,
127 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
128
129 g_object_class_install_property (object_class, PROP_DISPATCHER,
130 g_param_spec_object ("dispatcher", "dispatcher",
131 "The associated event dispatcher", WP_TYPE_EVENT_DISPATCHER,
132 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
133 }
134
135 /*!
136 * \brief Returns the name of the hook
137 *
138 * \ingroup wpeventhook
139 * \param self the event hook
140 * \return the event hook name
141 */
142 const gchar *
143 wp_event_hook_get_name (WpEventHook * self)
144 {
145 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), 0);
146 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
147 return priv->name;
148 }
149
150 /*!
151 * \brief Returns the names of the hooks that should run after this hook,
152 * or in other words, this hook should run before them
153 *
154 * \ingroup wpeventhook
155 * \param self the event hook
156 * \return (array zero-terminated=1)(element-type utf8)(transfer none):
157 * a NULL-terminated array of hook names
158 */
159 const gchar * const *
160 wp_event_hook_get_runs_before_hooks (WpEventHook * self)
161 {
162 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), NULL);
163 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
164 return (const gchar * const *) priv->before;
165 }
166
167 /*!
168 * \brief Returns the names of the hooks that should run before this hook,
169 * or in other words, this hook should run after them
170 *
171 * \ingroup wpeventhook
172 * \param self the event hook
173 * \return (array zero-terminated=1)(element-type utf8)(transfer none):
174 * a NULL-terminated array of hook names
175 */
176 const gchar * const *
177 wp_event_hook_get_runs_after_hooks (WpEventHook * self)
178 {
179 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), NULL);
180 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
181 return (const gchar * const *) priv->after;
182 }
183
184 /*!
185 * \brief Returns the associated event dispatcher
186 *
187 * \private
188 * \ingroup wpeventhook
189 * \param self the event hook
190 * \return (transfer full)(nullable): the event dispatcher on which this hook
191 * is registered, or NULL if the hook is not registered
192 */
193 WpEventDispatcher *
194 wp_event_hook_get_dispatcher (WpEventHook * self)
195 {
196 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), NULL);
197 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
198 return g_weak_ref_get (&priv->dispatcher);
199 }
200
201 /*!
202 * \brief Sets the associated event dispatcher
203 *
204 * \private
205 * \ingroup wpeventhook
206 * \param self the event hook
207 * \param dispatcher (transfer none): the event dispatcher on which
208 * this hook is registered
209 */
210 void
211 wp_event_hook_set_dispatcher (WpEventHook * self, WpEventDispatcher * dispatcher)
212 {
213 WpEventHookPrivate *priv = wp_event_hook_get_instance_private (self);
214 wp_trace_object (dispatcher, "hook (%s) registered", priv->name);
215 g_weak_ref_set (&priv->dispatcher, dispatcher);
216 }
217
218 /*!
219 * \brief Checks if the hook should be executed for a given event
220 *
221 * \ingroup wpeventhook
222 * \param self the event hook
223 * \param event the event
224 * \return TRUE if the hook should be executed for the given event,
225 * FALSE otherwise
226 */
227 gboolean
228 wp_event_hook_runs_for_event (WpEventHook * self, WpEvent * event)
229 {
230 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), FALSE);
231 g_return_val_if_fail (WP_EVENT_HOOK_GET_CLASS (self)->runs_for_event, FALSE);
232 return WP_EVENT_HOOK_GET_CLASS (self)->runs_for_event (self, event);
233 }
234
235 /*!
236 * \brief Runs the hook on the given event
237 *
238 * \ingroup wpeventhook
239 * \param self the event hook
240 * \param event the event that triggered the hook
241 * \param cancellable (nullable): a GCancellable to cancel the async operation
242 * \param callback (scope async)(closure callback_data): a callback to fire after execution of the hook
243 * has completed
244 * \param callback_data data for the callback
245 */
246 void
247 wp_event_hook_run (WpEventHook * self,
248 WpEvent * event, GCancellable * cancellable,
249 GAsyncReadyCallback callback, gpointer callback_data)
250 {
251 g_return_if_fail (WP_IS_EVENT_HOOK (self));
252 g_return_if_fail (WP_EVENT_HOOK_GET_CLASS (self)->run);
253 WP_EVENT_HOOK_GET_CLASS (self)->run (self, event, cancellable, callback,
254 callback_data);
255 }
256
257 /*!
258 * \brief Gets all the matching event types for this hook if any.
259 *
260 * \ingroup wpeventhook
261 * \param self the event hook
262 * \returns (element-type gchar*) (transfer full) (nullable): the matching
263 * event types for this hook if any.
264 * \since 0.5.13
265 */
266 GPtrArray *
267 wp_event_hook_get_matching_event_types (WpEventHook * self)
268 {
269 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), NULL);
270 g_return_val_if_fail (
271 WP_EVENT_HOOK_GET_CLASS (self)->get_matching_event_types, NULL);
272 return WP_EVENT_HOOK_GET_CLASS (self)->get_matching_event_types (self);
273 }
274
275 /*!
276 * \brief Finishes the async operation that was started by wp_event_hook_run()
277 *
278 * \ingroup wpeventhook
279 * \param self the event hook
280 * \param res the async operation result
281 * \param error (out) (optional): the error of the operation, if any
282 * \returns FALSE if there was an error, TRUE otherwise
283 */
284 gboolean
285 wp_event_hook_finish (WpEventHook * self, GAsyncResult * res, GError ** error)
286 {
287 g_return_val_if_fail (WP_IS_EVENT_HOOK (self), FALSE);
288 g_return_val_if_fail (WP_EVENT_HOOK_GET_CLASS (self)->finish, FALSE);
289 return WP_EVENT_HOOK_GET_CLASS (self)->finish (self, res, error);
290 }
291
292
293
294 /*!
295 * \struct WpInterestEventHook
296 *
297 * An event hook that declares interest in specific events. This subclass
298 * implements the WpEventHook.runs_for_event() vmethod and returns TRUE from
299 * that method if the given event has properties that match one of the declared
300 * interests.
301 */
302
303 typedef struct _WpInterestEventHookPrivate WpInterestEventHookPrivate;
304 struct _WpInterestEventHookPrivate
305 {
306 /* element-type: WpObjectInterest* */
307 GPtrArray *interests;
308 };
309
310 G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (WpInterestEventHook,
311 wp_interest_event_hook, WP_TYPE_EVENT_HOOK)
312
313 static void
314 wp_interest_event_hook_init (WpInterestEventHook * self)
315 {
316 WpInterestEventHookPrivate *priv =
317 wp_interest_event_hook_get_instance_private (self);
318 priv->interests = g_ptr_array_new_with_free_func (
319 (GDestroyNotify) wp_object_interest_unref);
320 }
321
322 static void
323 wp_interest_event_hook_finalize (GObject * object)
324 {
325 WpInterestEventHook *self = WP_INTEREST_EVENT_HOOK (object);
326 WpInterestEventHookPrivate *priv =
327 wp_interest_event_hook_get_instance_private (self);
328
329 g_clear_pointer (&priv->interests, g_ptr_array_unref);
330
331 G_OBJECT_CLASS (wp_interest_event_hook_parent_class)->finalize (object);
332 }
333
334 static gboolean
335 wp_interest_event_hook_runs_for_event (WpEventHook * hook, WpEvent * event)
336 {
337 WpInterestEventHook *self = WP_INTEREST_EVENT_HOOK (hook);
338 WpInterestEventHookPrivate *priv =
339 wp_interest_event_hook_get_instance_private (self);
340 g_autoptr (WpProperties) properties = wp_event_get_properties (event);
341 g_autoptr (GObject) subject = wp_event_get_subject (event);
342 guint i;
343 WpObjectInterest *interest = NULL;
344
345 for (i = 0; i < priv->interests->len; i++) {
346 interest = g_ptr_array_index (priv->interests, i);
347 if (wp_object_interest_matches_full (interest,
348 WP_INTEREST_MATCH_FLAGS_NONE,
349 WP_TYPE_EVENT, subject, properties, properties) == WP_INTEREST_MATCH_ALL)
350 return TRUE;
351 }
352 return FALSE;
353 }
354
355 static void
356 add_unique (GPtrArray *array, const gchar * lookup)
357 {
358 for (guint i = 0; i < array->len; i++)
359 if (g_str_equal (g_ptr_array_index (array, i), lookup))
360 return;
361 g_ptr_array_add (array, g_strdup (lookup));
362 }
363
364 static GPtrArray *
365 wp_interest_event_hook_get_matching_event_types (WpEventHook * hook)
366 {
367 WpInterestEventHook *self = WP_INTEREST_EVENT_HOOK (hook);
368 WpInterestEventHookPrivate *priv =
369 wp_interest_event_hook_get_instance_private (self);
370 g_autoptr (GPtrArray) res = g_ptr_array_new_with_free_func (g_free);
371 guint i;
372
373 for (i = 0; i < priv->interests->len; i++) {
374 WpObjectInterest *interest = g_ptr_array_index (priv->interests, i);
375 if (wp_object_interest_matches_full (interest, WP_INTEREST_MATCH_FLAGS_NONE,
376 WP_TYPE_EVENT, NULL, NULL, NULL) & WP_INTEREST_MATCH_GTYPE) {
377 g_autoptr (GPtrArray) values =
378 wp_object_interest_find_defined_constraint_values (interest,
379 WP_CONSTRAINT_TYPE_NONE, "event.type");
380 if (!values || values->len == 0) {
381 /* We always consider the hook undefined if it has at least one interest
382 * without a defined 'event.type' constraint */
383 return NULL;
384 } else {
385 for (guint j = 0; j < values->len; j++) {
386 GVariant *v = g_ptr_array_index (values, j);
387 if (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING)) {
388 const gchar *v_str = g_variant_get_string (v, NULL);
389 add_unique (res, v_str);
390 }
391 }
392 }
393 }
394 }
395
396 return g_steal_pointer (&res);
397 }
398
399 static void
400 wp_interest_event_hook_class_init (WpInterestEventHookClass * klass)
401 {
402 GObjectClass *object_class = (GObjectClass *) klass;
403 WpEventHookClass *hook_class = (WpEventHookClass *) klass;
404
405 object_class->finalize = wp_interest_event_hook_finalize;
406 hook_class->runs_for_event = wp_interest_event_hook_runs_for_event;
407 hook_class->get_matching_event_types =
408 wp_interest_event_hook_get_matching_event_types;
409 }
410
411 /*!
412 * \brief Equivalent to:
413 * \code
414 * WpObjectInterest *i = wp_object_interest_new (WP_TYPE_EVENT, ...);
415 * wp_interest_event_hook_add_interest_full (self, i);
416 * \endcode
417 *
418 * The constraints specified in the variable arguments must follow the rules
419 * documented in wp_object_interest_new().
420 *
421 * \ingroup wpeventhook
422 * \param self the event hook
423 * \param ... a list of constraints, terminated by NULL
424 */
425 void
426 wp_interest_event_hook_add_interest (WpInterestEventHook * self, ...)
427 {
428 WpObjectInterest *interest;
429 va_list args;
430
431 g_return_if_fail (WP_IS_INTEREST_EVENT_HOOK (self));
432
433 va_start (args, self);
434 interest = wp_object_interest_new_valist (WP_TYPE_EVENT, &args);
435 wp_interest_event_hook_add_interest_full (self, interest);
436 va_end (args);
437 }
438
439 /*!
440 * \brief Declares interest on events. The interest must be constructed to
441 * match WP_TYPE_EVENT objects and it is going to be matched against
442 * the WpEvent's properties.
443 *
444 * \param self the event hook
445 * \param interest (transfer full): the event interest
446 */
447 void
448 wp_interest_event_hook_add_interest_full (WpInterestEventHook * self,
449 WpObjectInterest * interest)
450 {
451 g_autoptr (GError) error = NULL;
452
453 g_return_if_fail (WP_IS_INTEREST_EVENT_HOOK (self));
454
455 if (G_UNLIKELY (!wp_object_interest_validate (interest, &error))) {
456 wp_critical_object (self, "interest validation failed: %s",
457 error->message);
458 wp_object_interest_unref (interest);
459 return;
460 }
461
462 WpInterestEventHookPrivate *priv =
463 wp_interest_event_hook_get_instance_private (self);
464 g_ptr_array_add (priv->interests, interest);
465 }
466
467
468
469 /*!
470 * \struct WpSimpleEventHook
471 *
472 * An event hook that runs a GClosure, synchronously.
473 */
474
475 struct _WpSimpleEventHook
476 {
477 WpInterestEventHook parent;
478 GClosure *closure;
479 };
480
481 enum {
482 PROP_SIMPLE_0,
483 PROP_SIMPLE_CLOSURE,
484 };
485
486 G_DEFINE_TYPE (WpSimpleEventHook, wp_simple_event_hook,
487 WP_TYPE_INTEREST_EVENT_HOOK)
488
489 static void
490 wp_simple_event_hook_init (WpSimpleEventHook * self)
491 {
492 }
493
494 static void
495 wp_simple_event_hook_finalize (GObject * object)
496 {
497 WpSimpleEventHook *self = WP_SIMPLE_EVENT_HOOK (object);
498
499 g_clear_pointer (&self->closure, g_closure_unref);
500
501 G_OBJECT_CLASS (wp_simple_event_hook_parent_class)->finalize (object);
502 }
503
504 static void
505 wp_simple_event_hook_set_property (GObject * object, guint property_id,
506 const GValue * value, GParamSpec * pspec)
507 {
508 WpSimpleEventHook *self = WP_SIMPLE_EVENT_HOOK (object);
509
510 switch (property_id) {
511 case PROP_SIMPLE_CLOSURE:
512 self->closure = g_value_dup_boxed (value);
513 g_closure_sink (self->closure);
514 if (G_CLOSURE_NEEDS_MARSHAL (self->closure))
515 g_closure_set_marshal (self->closure, g_cclosure_marshal_generic);
516 break;
517 default:
518 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
519 break;
520 }
521 }
522
523 static void
524 wp_simple_event_hook_run (WpEventHook * hook,
525 WpEvent * event, GCancellable * cancellable,
526 GAsyncReadyCallback callback, gpointer callback_data)
527 {
528 WpSimpleEventHook *self = WP_SIMPLE_EVENT_HOOK (hook);
529
530 GValue values[2] = { G_VALUE_INIT };
531 g_value_init (&values[0], WP_TYPE_EVENT);
532 g_value_set_boxed (&values[0], event);
533 g_closure_invoke (self->closure, NULL, 1, values, NULL);
534 g_value_unset (&values[0]);
535
536 callback ((GObject *) self, NULL, callback_data);
537 }
538
539 static gboolean
540 wp_simple_event_hook_finish (WpEventHook * hook, GAsyncResult * res,
541 GError ** error)
542 {
543 return TRUE;
544 }
545
546 static void
547 wp_simple_event_hook_class_init (WpSimpleEventHookClass * klass)
548 {
549 GObjectClass *object_class = (GObjectClass *) klass;
550 WpEventHookClass *hook_class = (WpEventHookClass *) klass;
551
552 object_class->finalize = wp_simple_event_hook_finalize;
553 object_class->set_property = wp_simple_event_hook_set_property;
554 hook_class->run = wp_simple_event_hook_run;
555 hook_class->finish = wp_simple_event_hook_finish;
556
557 g_object_class_install_property (object_class, PROP_SIMPLE_CLOSURE,
558 g_param_spec_boxed ("closure", "closure", "The closure", G_TYPE_CLOSURE,
559 G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
560 }
561
562 /*!
563 * \brief Constructs a new simple event hook
564 *
565 * \param name the name of the hook
566 * \param before (array zero-terminated=1)(element-type utf8)(transfer none)(nullable):
567 * an array of hook names that should run after this hook
568 * \param after (array zero-terminated=1)(element-type utf8)(transfer none)(nullable):
569 * an array of hook names that should run before this hook
570 * \param closure the closure to invoke when the hook is executed; the closure
571 * should accept two parameters: the event dispatcher and the event, returning
572 * nothing
573 * \return a new simple event hook
574 */
575 WpEventHook *
576 wp_simple_event_hook_new (const gchar *name,
577 const gchar * before[], const gchar * after[], GClosure * closure)
578 {
579 g_return_val_if_fail (closure != NULL, NULL);
580
581 return g_object_new (WP_TYPE_SIMPLE_EVENT_HOOK,
582 "name", name,
583 "runs-before-hooks", before,
584 "runs-after-hooks", after,
585 "closure", closure,
586 NULL);
587 }
588
589
590 /* WpAsyncEventHookTransition */
591
592 #define WP_TYPE_ASYNC_EVENT_HOOK_TRANSITION \
593 (wp_async_event_hook_transition_get_type ())
594 G_DECLARE_FINAL_TYPE (WpAsyncEventHookTransition,
595 wp_async_event_hook_transition,
596 WP, ASYNC_EVENT_HOOK_TRANSITION, WpTransition)
597
598
599 /*!
600 * \struct WpAsyncEventHook
601 *
602 * An event hook that runs a WpTransition, implemented with closures.
603 */
604
605 struct _WpAsyncEventHook
606 {
607 WpInterestEventHook parent;
608 GClosure *get_next_step;
609 GClosure *execute_step;
610 };
611
612 enum {
613 PROP_ASYNC_0,
614 PROP_ASYNC_GET_NEXT_STEP,
615 PROP_ASYNC_EXECUTE_STEP,
616 };
617
618 G_DEFINE_TYPE (WpAsyncEventHook, wp_async_event_hook,
619 WP_TYPE_INTEREST_EVENT_HOOK)
620
621 static void
622 wp_async_event_hook_init (WpAsyncEventHook * self)
623 {
624 }
625
626 static void
627 wp_async_event_hook_finalize (GObject * object)
628 {
629 WpAsyncEventHook *self = WP_ASYNC_EVENT_HOOK (object);
630
631 g_clear_pointer (&self->get_next_step, g_closure_unref);
632 g_clear_pointer (&self->execute_step, g_closure_unref);
633
634 G_OBJECT_CLASS (wp_async_event_hook_parent_class)->finalize (object);
635 }
636
637 static void
638 wp_async_event_hook_set_property (GObject * object, guint property_id,
639 const GValue * value, GParamSpec * pspec)
640 {
641 WpAsyncEventHook *self = WP_ASYNC_EVENT_HOOK (object);
642
643 switch (property_id) {
644 case PROP_ASYNC_GET_NEXT_STEP:
645 self->get_next_step = g_value_dup_boxed (value);
646 g_closure_sink (self->get_next_step);
647 if (G_CLOSURE_NEEDS_MARSHAL (self->get_next_step))
648 g_closure_set_marshal (self->get_next_step, g_cclosure_marshal_generic);
649 break;
650 case PROP_ASYNC_EXECUTE_STEP:
651 self->execute_step = g_value_dup_boxed (value);
652 g_closure_sink (self->execute_step);
653 if (G_CLOSURE_NEEDS_MARSHAL (self->execute_step))
654 g_closure_set_marshal (self->execute_step, g_cclosure_marshal_VOID__UINT);
655 break;
656 default:
657 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
658 break;
659 }
660 }
661
662 static void
663 wp_async_event_hook_run (WpEventHook * hook,
664 WpEvent * event, GCancellable * cancellable,
665 GAsyncReadyCallback callback, gpointer callback_data)
666 {
667 WpTransition *transition = wp_transition_new (
668 WP_TYPE_ASYNC_EVENT_HOOK_TRANSITION,
669 hook, cancellable, callback, callback_data);
670 wp_transition_set_data (transition, wp_event_ref (event),
671 (GDestroyNotify) wp_event_unref);
672 wp_transition_set_source_tag (transition, wp_async_event_hook_run);
673 wp_transition_advance (transition);
674 }
675
676 static gboolean
677 wp_async_event_hook_finish (WpEventHook * hook, GAsyncResult * res,
678 GError ** error)
679 {
680 g_return_val_if_fail (g_async_result_is_tagged (res, wp_async_event_hook_run),
681 FALSE);
682 return wp_transition_finish (res, error);
683 }
684
685 static void
686 wp_async_event_hook_class_init (WpAsyncEventHookClass * klass)
687 {
688 GObjectClass *object_class = (GObjectClass *) klass;
689 WpEventHookClass *hook_class = (WpEventHookClass *) klass;
690
691 object_class->finalize = wp_async_event_hook_finalize;
692 object_class->set_property = wp_async_event_hook_set_property;
693 hook_class->run = wp_async_event_hook_run;
694 hook_class->finish = wp_async_event_hook_finish;
695
696 g_object_class_install_property (object_class, PROP_ASYNC_GET_NEXT_STEP,
697 g_param_spec_boxed ("get-next-step", "get-next-step",
698 "The get-next-step closure", G_TYPE_CLOSURE,
699 G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
700
701 g_object_class_install_property (object_class, PROP_ASYNC_EXECUTE_STEP,
702 g_param_spec_boxed ("execute-step", "execute-step",
703 "The execute-step closure", G_TYPE_CLOSURE,
704 G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
705 }
706
707 /*!
708 * \brief Constructs a new async event hook
709 *
710 * \param name the name of the hook
711 * \param before (array zero-terminated=1)(element-type utf8)(transfer none)(nullable):
712 * an array of hook names that should run after this hook
713 * \param after (array zero-terminated=1)(element-type utf8)(transfer none)(nullable):
714 * an array of hook names that should run before this hook
715 * \param get_next_step the closure to invoke to get the next step
716 * \param execute_step the closure to invoke to execute the step
717 * \return a new async event hook
718 */
719 WpEventHook *
720 wp_async_event_hook_new (const gchar *name,
721 const gchar * before[], const gchar * after[],
722 GClosure * get_next_step, GClosure * execute_step)
723 {
724 g_return_val_if_fail (get_next_step != NULL, NULL);
725 g_return_val_if_fail (execute_step != NULL, NULL);
726
727 return g_object_new (WP_TYPE_ASYNC_EVENT_HOOK,
728 "name", name,
729 "runs-before-hooks", before,
730 "runs-after-hooks", after,
731 "get-next-step", get_next_step,
732 "execute-step", execute_step,
733 NULL);
734 }
735
736
737 /* WpAsyncEventHookTransition - implementation */
738
739 struct _WpAsyncEventHookTransition
740 {
741 WpTransition parent;
742 };
743
744 G_DEFINE_TYPE (WpAsyncEventHookTransition,
745 wp_async_event_hook_transition,
746 WP_TYPE_TRANSITION)
747
748 static void
749 wp_async_event_hook_transition_init (
750 WpAsyncEventHookTransition * transition)
751 {
752 }
753
754 static guint
755 wp_async_event_hook_transition_get_next_step (
756 WpTransition * transition, guint step)
757 {
758 WpAsyncEventHook *hook =
759 WP_ASYNC_EVENT_HOOK (wp_transition_get_source_object (transition));
760 guint next_step = WP_TRANSITION_STEP_ERROR;
761 GValue ret = G_VALUE_INIT;
762 GValue values[2] = { G_VALUE_INIT, G_VALUE_INIT };
763
764 g_value_init (&ret, G_TYPE_UINT);
765 g_value_init (&values[0], G_TYPE_OBJECT);
766 g_value_init (&values[1], G_TYPE_UINT);
767 g_value_set_object (&values[0], transition);
768 g_value_set_uint (&values[1], step);
769 g_closure_invoke (hook->get_next_step, &ret, 2, values, NULL);
770 g_value_unset (&values[0]);
771 g_value_unset (&values[1]);
772 next_step = g_value_get_uint (&ret);
773 g_value_unset (&ret);
774 return next_step;
775 }
776
777 static void
778 wp_async_event_hook_transition_execute_step (
779 WpTransition * transition, guint step)
780 {
781 WpAsyncEventHook *hook =
782 WP_ASYNC_EVENT_HOOK (wp_transition_get_source_object (transition));
783 GValue values[2] = { G_VALUE_INIT, G_VALUE_INIT };
784
785 g_value_init (&values[0], G_TYPE_OBJECT);
786 g_value_init (&values[1], G_TYPE_UINT);
787 g_value_set_object (&values[0], transition);
788 g_value_set_uint (&values[1], step);
789 g_closure_invoke (hook->execute_step, NULL, 2, values, NULL);
790 g_value_unset (&values[0]);
791 g_value_unset (&values[1]);
792 }
793
794 static void
795 wp_async_event_hook_transition_class_init (
796 WpAsyncEventHookTransitionClass * klass)
797 {
798 WpTransitionClass *transition_class = (WpTransitionClass *) klass;
799
800 transition_class->get_next_step =
801 wp_async_event_hook_transition_get_next_step;
802 transition_class->execute_step =
803 wp_async_event_hook_transition_execute_step;
804 }