← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/indicator-sound/oneiric

« back to all changes in this revision

Viewing changes to src/mpris2-watcher.c

Tags: 0.7.8-0ubuntu1
https://launchpad.net/bugs/855557
* New upstream release.
  - indicator-sound interferes with gnome-settings-daemon (LP: #855557)
* debian/patches/01_fix_FTBFS.patch
  - Dropped, fixed upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mpris2-watcher.c
1
 
/* mpris2-watcher.c generated by valac 0.12.1, the Vala compiler
 
1
/* mpris2-watcher.c generated by valac 0.14.0, the Vala compiler
2
2
 * generated from mpris2-watcher.vala, do not modify */
3
3
 
4
4
/*
120
120
        gchar** interfaces;
121
121
        gint interfaces_length1;
122
122
        gint _interfaces_size_;
123
 
        gint _tmp0_;
124
 
        gchar** _tmp1_;
 
123
        FreeDesktopObject* _tmp0_;
 
124
        gint _tmp1_;
125
125
        gchar** _tmp2_;
126
 
        gint _tmp2__length1;
127
 
        gint __tmp2__size_;
128
 
        GError * e;
 
126
        gchar** _tmp3_;
 
127
        gint _tmp3__length1;
 
128
        gint __tmp3__size_;
 
129
        GError* e;
 
130
        GError* _tmp4_;
 
131
        const gchar* _tmp5_;
 
132
        gchar** _tmp6_;
 
133
        gint _tmp6__length1;
129
134
        gchar** address_collection;
130
 
        int address_collection_length1;
131
 
        int address_it;
132
 
        gchar* _tmp3_;
 
135
        gint address_collection_length1;
 
136
        gint _address_collection_size_;
 
137
        gint address_it;
 
138
        gchar* _tmp7_;
133
139
        gchar* address;
134
 
        gboolean _tmp4_;
135
 
        MprisRoot* _tmp5_;
 
140
        const gchar* _tmp8_;
 
141
        gboolean _tmp9_;
 
142
        const gchar* _tmp10_;
 
143
        MprisRoot* _tmp11_;
136
144
        MprisRoot* mpris2_root;
137
 
        gboolean _tmp6_;
 
145
        MprisRoot* _tmp12_;
 
146
        const gchar* _tmp13_;
 
147
        gboolean _tmp14_;
138
148
        gboolean use_playlists;
139
 
        gchar* _tmp7_;
140
 
        gchar* _tmp8_;
 
149
        MprisRoot* _tmp15_;
 
150
        gchar* _tmp16_;
 
151
        gchar* _tmp17_;
 
152
        gchar* _tmp18_;
 
153
        const gchar* _tmp19_;
 
154
        gboolean _tmp20_;
141
155
        GError * _inner_error_;
142
156
};
143
157
 
162
176
static void mpris2_watcher_check_for_active_clients_data_free (gpointer _data);
163
177
void mpris2_watcher_check_for_active_clients (Mpris2Watcher* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
164
178
void mpris2_watcher_check_for_active_clients_finish (Mpris2Watcher* self, GAsyncResult* _res_);
165
 
static gboolean mpris2_watcher_check_for_active_clients_co (Mpris2WatcherCheckForActiveClientsData* data);
 
179
static gboolean mpris2_watcher_check_for_active_clients_co (Mpris2WatcherCheckForActiveClientsData* _data_);
166
180
void free_desktop_object_list_names (FreeDesktopObject* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
167
181
gchar** free_desktop_object_list_names_finish (FreeDesktopObject* self, GAsyncResult* _res_, int* result_length1, GError** error);
168
182
static void mpris2_watcher_check_for_active_clients_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
203
217
 
204
218
 
205
219
static void mpris2_watcher_check_for_active_clients_data_free (gpointer _data) {
206
 
        Mpris2WatcherCheckForActiveClientsData* data;
207
 
        data = _data;
208
 
        _g_object_unref0 (data->self);
209
 
        g_slice_free (Mpris2WatcherCheckForActiveClientsData, data);
 
220
        Mpris2WatcherCheckForActiveClientsData* _data_;
 
221
        _data_ = _data;
 
222
        _g_object_unref0 (_data_->self);
 
223
        g_slice_free (Mpris2WatcherCheckForActiveClientsData, _data_);
210
224
}
211
225
 
212
226
 
217
231
 
218
232
void mpris2_watcher_check_for_active_clients (Mpris2Watcher* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
219
233
        Mpris2WatcherCheckForActiveClientsData* _data_;
 
234
        Mpris2Watcher* _tmp0_;
220
235
        _data_ = g_slice_new0 (Mpris2WatcherCheckForActiveClientsData);
221
236
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, mpris2_watcher_check_for_active_clients);
222
237
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, mpris2_watcher_check_for_active_clients_data_free);
223
 
        _data_->self = _g_object_ref0 (self);
 
238
        _tmp0_ = _g_object_ref0 (self);
 
239
        _data_->self = _tmp0_;
224
240
        mpris2_watcher_check_for_active_clients_co (_data_);
225
241
}
226
242
 
232
248
 
233
249
 
234
250
static void mpris2_watcher_check_for_active_clients_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
235
 
        Mpris2WatcherCheckForActiveClientsData* data;
236
 
        data = _user_data_;
237
 
        data->_source_object_ = source_object;
238
 
        data->_res_ = _res_;
239
 
        mpris2_watcher_check_for_active_clients_co (data);
 
251
        Mpris2WatcherCheckForActiveClientsData* _data_;
 
252
        _data_ = _user_data_;
 
253
        _data_->_source_object_ = source_object;
 
254
        _data_->_res_ = _res_;
 
255
        mpris2_watcher_check_for_active_clients_co (_data_);
240
256
}
241
257
 
242
258
 
243
 
static gboolean mpris2_watcher_check_for_active_clients_co (Mpris2WatcherCheckForActiveClientsData* data) {
244
 
        switch (data->_state_) {
 
259
static gboolean mpris2_watcher_check_for_active_clients_co (Mpris2WatcherCheckForActiveClientsData* _data_) {
 
260
        switch (_data_->_state_) {
245
261
                case 0:
246
262
                goto _state_0;
247
263
                case 1:
250
266
                g_assert_not_reached ();
251
267
        }
252
268
        _state_0:
253
 
        data->interfaces_length1 = 0;
254
 
        data->_interfaces_size_ = 0;
255
 
        data->_state_ = 1;
256
 
        free_desktop_object_list_names (data->self->priv->fdesktop_obj, mpris2_watcher_check_for_active_clients_ready, data);
257
 
        return FALSE;
258
 
        _state_1:
259
 
        data->_tmp1_ = NULL;
260
 
        data->_tmp1_ = free_desktop_object_list_names_finish (data->self->priv->fdesktop_obj, data->_res_, &data->_tmp0_, &data->_inner_error_);
261
 
        data->_tmp2_ = data->_tmp1_;
262
 
        data->_tmp2__length1 = data->_tmp0_;
263
 
        data->__tmp2__size_ = data->_tmp0_;
264
 
        if (data->_inner_error_ != NULL) {
265
 
                if (data->_inner_error_->domain == G_IO_ERROR) {
266
 
                        goto __catch7_g_io_error;
 
269
        _data_->interfaces_length1 = 0;
 
270
        _data_->_interfaces_size_ = 0;
 
271
        {
 
272
                _data_->_tmp0_ = _data_->self->priv->fdesktop_obj;
 
273
                _data_->_tmp1_ = 0;
 
274
                _data_->_state_ = 1;
 
275
                free_desktop_object_list_names (_data_->_tmp0_, mpris2_watcher_check_for_active_clients_ready, _data_);
 
276
                return FALSE;
 
277
                _state_1:
 
278
                _data_->_tmp2_ = NULL;
 
279
                _data_->_tmp2_ = free_desktop_object_list_names_finish (_data_->_tmp0_, _data_->_res_, &_data_->_tmp1_, &_data_->_inner_error_);
 
280
                _data_->_tmp3_ = _data_->_tmp2_;
 
281
                _data_->_tmp3__length1 = _data_->_tmp1_;
 
282
                _data_->__tmp3__size_ = _data_->_tmp3__length1;
 
283
                if (_data_->_inner_error_ != NULL) {
 
284
                        if (_data_->_inner_error_->domain == G_IO_ERROR) {
 
285
                                goto __catch7_g_io_error;
 
286
                        }
 
287
                        _data_->interfaces = (_vala_array_free (_data_->interfaces, _data_->interfaces_length1, (GDestroyNotify) g_free), NULL);
 
288
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
 
289
                        g_clear_error (&_data_->_inner_error_);
 
290
                        return FALSE;
267
291
                }
268
 
                data->interfaces = (_vala_array_free (data->interfaces, data->interfaces_length1, (GDestroyNotify) g_free), NULL);
269
 
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
270
 
                g_clear_error (&data->_inner_error_);
271
 
                return FALSE;
 
292
                _data_->interfaces = (_vala_array_free (_data_->interfaces, _data_->interfaces_length1, (GDestroyNotify) g_free), NULL);
 
293
                _data_->interfaces = _data_->_tmp3_;
 
294
                _data_->interfaces_length1 = _data_->_tmp3__length1;
 
295
                _data_->_interfaces_size_ = _data_->interfaces_length1;
272
296
        }
273
 
        data->interfaces = (_vala_array_free (data->interfaces, data->interfaces_length1, (GDestroyNotify) g_free), NULL);
274
 
        data->interfaces = data->_tmp2_;
275
 
        data->interfaces_length1 = data->_tmp2__length1;
276
 
        data->_interfaces_size_ = data->_tmp2__length1;
277
297
        goto __finally7;
278
298
        __catch7_g_io_error:
279
299
        {
280
 
                data->e = data->_inner_error_;
281
 
                data->_inner_error_ = NULL;
 
300
                _data_->e = _data_->_inner_error_;
 
301
                _data_->_inner_error_ = NULL;
 
302
                _data_->_tmp4_ = _data_->e;
 
303
                _data_->_tmp5_ = _data_->_tmp4_->message;
282
304
                g_warning ("mpris2-watcher.vala:60: Mpris2watcher could fetch active interfaces at" \
283
 
" startup: %s", data->e->message);
284
 
                _g_error_free0 (data->e);
285
 
                data->interfaces = (_vala_array_free (data->interfaces, data->interfaces_length1, (GDestroyNotify) g_free), NULL);
286
 
                if (data->_state_ == 0) {
287
 
                        g_simple_async_result_complete_in_idle (data->_async_result);
 
305
" startup: %s", _data_->_tmp5_);
 
306
                _g_error_free0 (_data_->e);
 
307
                _data_->interfaces = (_vala_array_free (_data_->interfaces, _data_->interfaces_length1, (GDestroyNotify) g_free), NULL);
 
308
                if (_data_->_state_ == 0) {
 
309
                        g_simple_async_result_complete_in_idle (_data_->_async_result);
288
310
                } else {
289
 
                        g_simple_async_result_complete (data->_async_result);
 
311
                        g_simple_async_result_complete (_data_->_async_result);
290
312
                }
291
 
                g_object_unref (data->_async_result);
 
313
                g_object_unref (_data_->_async_result);
292
314
                return FALSE;
293
315
        }
294
316
        __finally7:
295
 
        if (data->_inner_error_ != NULL) {
296
 
                data->interfaces = (_vala_array_free (data->interfaces, data->interfaces_length1, (GDestroyNotify) g_free), NULL);
297
 
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
298
 
                g_clear_error (&data->_inner_error_);
 
317
        if (_data_->_inner_error_ != NULL) {
 
318
                _data_->interfaces = (_vala_array_free (_data_->interfaces, _data_->interfaces_length1, (GDestroyNotify) g_free), NULL);
 
319
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
 
320
                g_clear_error (&_data_->_inner_error_);
299
321
                return FALSE;
300
322
        }
 
323
        _data_->_tmp6_ = _data_->interfaces;
 
324
        _data_->_tmp6__length1 = _data_->interfaces_length1;
301
325
        {
302
 
                data->address_collection = data->interfaces;
303
 
                data->address_collection_length1 = data->interfaces_length1;
304
 
                for (data->address_it = 0; data->address_it < data->interfaces_length1; data->address_it = data->address_it + 1) {
305
 
                        data->_tmp3_ = g_strdup (data->address_collection[data->address_it]);
306
 
                        data->address = data->_tmp3_;
 
326
                _data_->address_collection_length1 = 0;
 
327
                _data_->_address_collection_size_ = 0;
 
328
                _data_->address_collection = _data_->_tmp6_;
 
329
                _data_->address_collection_length1 = _data_->_tmp6__length1;
 
330
                _data_->address_it = 0;
 
331
                for (_data_->address_it = 0; _data_->address_it < _data_->_tmp6__length1; _data_->address_it = _data_->address_it + 1) {
 
332
                        _data_->_tmp7_ = g_strdup (_data_->address_collection[_data_->address_it]);
 
333
                        _data_->address = _data_->_tmp7_;
307
334
                        {
308
 
                                data->_tmp4_ = g_str_has_prefix (data->address, MPRIS_PREFIX);
309
 
                                if (data->_tmp4_) {
310
 
                                        data->_tmp5_ = NULL;
311
 
                                        data->_tmp5_ = mpris2_watcher_create_mpris_root (data->self, data->address);
312
 
                                        data->mpris2_root = data->_tmp5_;
313
 
                                        if (data->mpris2_root == NULL) {
314
 
                                                _g_object_unref0 (data->mpris2_root);
315
 
                                                _g_free0 (data->address);
316
 
                                                data->interfaces = (_vala_array_free (data->interfaces, data->interfaces_length1, (GDestroyNotify) g_free), NULL);
317
 
                                                if (data->_state_ == 0) {
318
 
                                                        g_simple_async_result_complete_in_idle (data->_async_result);
 
335
                                _data_->_tmp8_ = _data_->address;
 
336
                                _data_->_tmp9_ = FALSE;
 
337
                                _data_->_tmp9_ = g_str_has_prefix (_data_->_tmp8_, MPRIS_PREFIX);
 
338
                                if (_data_->_tmp9_) {
 
339
                                        _data_->_tmp10_ = _data_->address;
 
340
                                        _data_->_tmp11_ = NULL;
 
341
                                        _data_->_tmp11_ = mpris2_watcher_create_mpris_root (_data_->self, _data_->_tmp10_);
 
342
                                        _data_->mpris2_root = _data_->_tmp11_;
 
343
                                        _data_->_tmp12_ = _data_->mpris2_root;
 
344
                                        if (_data_->_tmp12_ == NULL) {
 
345
                                                _g_object_unref0 (_data_->mpris2_root);
 
346
                                                _g_free0 (_data_->address);
 
347
                                                _data_->interfaces = (_vala_array_free (_data_->interfaces, _data_->interfaces_length1, (GDestroyNotify) g_free), NULL);
 
348
                                                if (_data_->_state_ == 0) {
 
349
                                                        g_simple_async_result_complete_in_idle (_data_->_async_result);
319
350
                                                } else {
320
 
                                                        g_simple_async_result_complete (data->_async_result);
 
351
                                                        g_simple_async_result_complete (_data_->_async_result);
321
352
                                                }
322
 
                                                g_object_unref (data->_async_result);
 
353
                                                g_object_unref (_data_->_async_result);
323
354
                                                return FALSE;
324
355
                                        }
325
 
                                        data->_tmp6_ = mpris2_watcher_supports_playlists (data->self, data->address);
326
 
                                        data->use_playlists = data->_tmp6_;
327
 
                                        data->_tmp7_ = NULL;
328
 
                                        data->_tmp7_ = mpris_root_get_DesktopEntry (data->mpris2_root);
329
 
                                        data->_tmp8_ = data->_tmp7_;
330
 
                                        g_signal_emit_by_name (data->self, "client-appeared", data->_tmp8_, data->address, data->use_playlists);
331
 
                                        _g_free0 (data->_tmp8_);
332
 
                                        _g_object_unref0 (data->mpris2_root);
 
356
                                        _data_->_tmp13_ = _data_->address;
 
357
                                        _data_->_tmp14_ = FALSE;
 
358
                                        _data_->_tmp14_ = mpris2_watcher_supports_playlists (_data_->self, _data_->_tmp13_);
 
359
                                        _data_->use_playlists = _data_->_tmp14_;
 
360
                                        _data_->_tmp15_ = _data_->mpris2_root;
 
361
                                        _data_->_tmp16_ = mpris_root_get_DesktopEntry (_data_->_tmp15_);
 
362
                                        _data_->_tmp17_ = _data_->_tmp16_;
 
363
                                        _data_->_tmp18_ = _data_->_tmp17_;
 
364
                                        _data_->_tmp19_ = _data_->address;
 
365
                                        _data_->_tmp20_ = _data_->use_playlists;
 
366
                                        g_signal_emit_by_name (_data_->self, "client-appeared", _data_->_tmp18_, _data_->_tmp19_, _data_->_tmp20_);
 
367
                                        _g_free0 (_data_->_tmp18_);
 
368
                                        _g_object_unref0 (_data_->mpris2_root);
333
369
                                }
334
 
                                _g_free0 (data->address);
 
370
                                _g_free0 (_data_->address);
335
371
                        }
336
372
                }
337
373
        }
338
 
        data->interfaces = (_vala_array_free (data->interfaces, data->interfaces_length1, (GDestroyNotify) g_free), NULL);
339
 
        if (data->_state_ == 0) {
340
 
                g_simple_async_result_complete_in_idle (data->_async_result);
 
374
        _data_->interfaces = (_vala_array_free (_data_->interfaces, _data_->interfaces_length1, (GDestroyNotify) g_free), NULL);
 
375
        if (_data_->_state_ == 0) {
 
376
                g_simple_async_result_complete_in_idle (_data_->_async_result);
341
377
        } else {
342
 
                g_simple_async_result_complete (data->_async_result);
 
378
                g_simple_async_result_complete (_data_->_async_result);
343
379
        }
344
 
        g_object_unref (data->_async_result);
 
380
        g_object_unref (_data_->_async_result);
345
381
        return FALSE;
346
382
}
347
383
 
348
384
 
349
385
static void mpris2_watcher_name_changes_detected (Mpris2Watcher* self, FreeDesktopObject* dbus_obj, const gchar* name, const gchar* previous_owner, const gchar* current_owner) {
350
 
        MprisRoot* _tmp0_ = NULL;
 
386
        const gchar* _tmp0_;
 
387
        MprisRoot* _tmp1_ = NULL;
351
388
        MprisRoot* mpris2_root;
352
 
        gboolean _tmp1_ = FALSE;
 
389
        MprisRoot* _tmp2_;
 
390
        gboolean _tmp3_ = FALSE;
 
391
        const gchar* _tmp4_;
 
392
        gboolean _tmp6_;
353
393
        g_return_if_fail (self != NULL);
354
394
        g_return_if_fail (dbus_obj != NULL);
355
395
        g_return_if_fail (name != NULL);
356
396
        g_return_if_fail (previous_owner != NULL);
357
397
        g_return_if_fail (current_owner != NULL);
358
 
        _tmp0_ = mpris2_watcher_create_mpris_root (self, name);
359
 
        mpris2_root = _tmp0_;
360
 
        if (mpris2_root == NULL) {
 
398
        _tmp0_ = name;
 
399
        _tmp1_ = mpris2_watcher_create_mpris_root (self, _tmp0_);
 
400
        mpris2_root = _tmp1_;
 
401
        _tmp2_ = mpris2_root;
 
402
        if (_tmp2_ == NULL) {
361
403
                _g_object_unref0 (mpris2_root);
362
404
                return;
363
405
        }
364
 
        if (g_strcmp0 (previous_owner, "") != 0) {
365
 
                _tmp1_ = g_strcmp0 (current_owner, "") == 0;
 
406
        _tmp4_ = previous_owner;
 
407
        if (g_strcmp0 (_tmp4_, "") != 0) {
 
408
                const gchar* _tmp5_;
 
409
                _tmp5_ = current_owner;
 
410
                _tmp3_ = g_strcmp0 (_tmp5_, "") == 0;
366
411
        } else {
367
 
                _tmp1_ = FALSE;
 
412
                _tmp3_ = FALSE;
368
413
        }
369
 
        if (_tmp1_) {
370
 
                g_debug ("mpris2-watcher.vala:84: Client '%s' gone down", name);
371
 
                g_signal_emit_by_name (self, "client-disappeared", name);
 
414
        _tmp6_ = _tmp3_;
 
415
        if (_tmp6_) {
 
416
                const gchar* _tmp7_;
 
417
                const gchar* _tmp8_;
 
418
                _tmp7_ = name;
 
419
                g_debug ("mpris2-watcher.vala:84: Client '%s' gone down", _tmp7_);
 
420
                _tmp8_ = name;
 
421
                g_signal_emit_by_name (self, "client-disappeared", _tmp8_);
372
422
        } else {
373
 
                gboolean _tmp2_ = FALSE;
374
 
                if (g_strcmp0 (previous_owner, "") == 0) {
375
 
                        _tmp2_ = g_strcmp0 (current_owner, "") != 0;
 
423
                gboolean _tmp9_ = FALSE;
 
424
                const gchar* _tmp10_;
 
425
                gboolean _tmp12_;
 
426
                _tmp10_ = previous_owner;
 
427
                if (g_strcmp0 (_tmp10_, "") == 0) {
 
428
                        const gchar* _tmp11_;
 
429
                        _tmp11_ = current_owner;
 
430
                        _tmp9_ = g_strcmp0 (_tmp11_, "") != 0;
376
431
                } else {
377
 
                        _tmp2_ = FALSE;
 
432
                        _tmp9_ = FALSE;
378
433
                }
379
 
                if (_tmp2_) {
380
 
                        gboolean _tmp3_;
 
434
                _tmp12_ = _tmp9_;
 
435
                if (_tmp12_) {
 
436
                        const gchar* _tmp13_;
 
437
                        const gchar* _tmp14_;
 
438
                        gboolean _tmp15_ = FALSE;
381
439
                        gboolean use_playlists;
382
 
                        gchar* _tmp4_ = NULL;
383
 
                        gchar* _tmp5_;
384
 
                        g_debug ("mpris2-watcher.vala:88: Client '%s' has appeared", name);
385
 
                        _tmp3_ = mpris2_watcher_supports_playlists (self, name);
386
 
                        use_playlists = _tmp3_;
387
 
                        _tmp4_ = mpris_root_get_DesktopEntry (mpris2_root);
388
 
                        _tmp5_ = _tmp4_;
389
 
                        g_signal_emit_by_name (self, "client-appeared", _tmp5_, name, use_playlists);
390
 
                        _g_free0 (_tmp5_);
 
440
                        MprisRoot* _tmp16_;
 
441
                        gchar* _tmp17_;
 
442
                        gchar* _tmp18_;
 
443
                        gchar* _tmp19_;
 
444
                        const gchar* _tmp20_;
 
445
                        gboolean _tmp21_;
 
446
                        _tmp13_ = name;
 
447
                        g_debug ("mpris2-watcher.vala:88: Client '%s' has appeared", _tmp13_);
 
448
                        _tmp14_ = name;
 
449
                        _tmp15_ = mpris2_watcher_supports_playlists (self, _tmp14_);
 
450
                        use_playlists = _tmp15_;
 
451
                        _tmp16_ = mpris2_root;
 
452
                        _tmp17_ = mpris_root_get_DesktopEntry (_tmp16_);
 
453
                        _tmp18_ = _tmp17_;
 
454
                        _tmp19_ = _tmp18_;
 
455
                        _tmp20_ = name;
 
456
                        _tmp21_ = use_playlists;
 
457
                        g_signal_emit_by_name (self, "client-appeared", _tmp19_, _tmp20_, _tmp21_);
 
458
                        _g_free0 (_tmp19_);
391
459
                }
392
460
        }
393
461
        _g_object_unref0 (mpris2_root);
397
465
static MprisRoot* mpris2_watcher_create_mpris_root (Mpris2Watcher* self, const gchar* name) {
398
466
        MprisRoot* result = NULL;
399
467
        MprisRoot* mpris2_root;
400
 
        gboolean _tmp0_;
 
468
        const gchar* _tmp0_;
 
469
        gboolean _tmp1_ = FALSE;
401
470
        GError * _inner_error_ = NULL;
402
471
        g_return_val_if_fail (self != NULL, NULL);
403
472
        g_return_val_if_fail (name != NULL, NULL);
404
473
        mpris2_root = NULL;
405
 
        _tmp0_ = g_str_has_prefix (name, MPRIS_PREFIX);
406
 
        if (_tmp0_) {
407
 
                MprisRoot* _tmp1_ = NULL;
408
 
                MprisRoot* _tmp2_;
409
 
                _tmp1_ = g_initable_new (TYPE_MPRIS_ROOT_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", name, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", MPRIS_MEDIA_PLAYER_PATH, "g-interface-name", "org.mpris.MediaPlayer2", NULL);
410
 
                _tmp2_ = (MprisRoot*) _tmp1_;
411
 
                if (_inner_error_ != NULL) {
412
 
                        if (_inner_error_->domain == G_IO_ERROR) {
413
 
                                goto __catch8_g_io_error;
 
474
        _tmp0_ = name;
 
475
        _tmp1_ = g_str_has_prefix (_tmp0_, MPRIS_PREFIX);
 
476
        if (_tmp1_) {
 
477
                {
 
478
                        const gchar* _tmp2_;
 
479
                        MprisRoot* _tmp3_ = NULL;
 
480
                        MprisRoot* _tmp4_;
 
481
                        _tmp2_ = name;
 
482
                        _tmp3_ = g_initable_new (TYPE_MPRIS_ROOT_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", _tmp2_, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", MPRIS_MEDIA_PLAYER_PATH, "g-interface-name", "org.mpris.MediaPlayer2", NULL);
 
483
                        _tmp4_ = (MprisRoot*) _tmp3_;
 
484
                        if (_inner_error_ != NULL) {
 
485
                                if (_inner_error_->domain == G_IO_ERROR) {
 
486
                                        goto __catch8_g_io_error;
 
487
                                }
 
488
                                _g_object_unref0 (mpris2_root);
 
489
                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
490
                                g_clear_error (&_inner_error_);
 
491
                                return NULL;
414
492
                        }
415
493
                        _g_object_unref0 (mpris2_root);
416
 
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
417
 
                        g_clear_error (&_inner_error_);
418
 
                        return NULL;
 
494
                        mpris2_root = _tmp4_;
419
495
                }
420
 
                _g_object_unref0 (mpris2_root);
421
 
                mpris2_root = _tmp2_;
422
496
                goto __finally8;
423
497
                __catch8_g_io_error:
424
498
                {
425
 
                        GError * e;
 
499
                        GError* e = NULL;
 
500
                        GError* _tmp5_;
 
501
                        const gchar* _tmp6_;
426
502
                        e = _inner_error_;
427
503
                        _inner_error_ = NULL;
 
504
                        _tmp5_ = e;
 
505
                        _tmp6_ = _tmp5_->message;
428
506
                        g_warning ("mpris2-watcher.vala:103: Mpris2watcher could not create a root interfa" \
429
 
"ce: %s", e->message);
 
507
"ce: %s", _tmp6_);
430
508
                        _g_error_free0 (e);
431
509
                }
432
510
                __finally8:
445
523
static gboolean mpris2_watcher_supports_playlists (Mpris2Watcher* self, const gchar* name) {
446
524
        gboolean result = FALSE;
447
525
        FreeDesktopIntrospectable* introspectable = NULL;
448
 
        FreeDesktopIntrospectable* _tmp0_ = NULL;
449
 
        FreeDesktopIntrospectable* _tmp1_;
450
 
        gchar* _tmp2_ = NULL;
451
 
        gchar* results;
452
 
        gboolean _tmp3_;
453
526
        GError * _inner_error_ = NULL;
454
527
        g_return_val_if_fail (self != NULL, FALSE);
455
528
        g_return_val_if_fail (name != NULL, FALSE);
456
 
        _tmp0_ = g_initable_new (TYPE_FREE_DESKTOP_INTROSPECTABLE_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "g-name", name, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", MPRIS_MEDIA_PLAYER_PATH, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL);
457
 
        _tmp1_ = (FreeDesktopIntrospectable*) _tmp0_;
458
 
        if (_inner_error_ != NULL) {
459
 
                if (_inner_error_->domain == G_IO_ERROR) {
460
 
                        goto __catch9_g_io_error;
461
 
                }
462
 
                _g_object_unref0 (introspectable);
463
 
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
464
 
                g_clear_error (&_inner_error_);
465
 
                return FALSE;
466
 
        }
467
 
        _g_object_unref0 (introspectable);
468
 
        introspectable = _tmp1_;
469
 
        _tmp2_ = free_desktop_introspectable_Introspect (introspectable, &_inner_error_);
470
 
        results = _tmp2_;
471
 
        if (_inner_error_ != NULL) {
472
 
                if (_inner_error_->domain == G_IO_ERROR) {
473
 
                        goto __catch9_g_io_error;
474
 
                }
475
 
                _g_object_unref0 (introspectable);
476
 
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
477
 
                g_clear_error (&_inner_error_);
478
 
                return FALSE;
479
 
        }
480
 
        _tmp3_ = mpris2_watcher_parse_interfaces (self, results);
481
 
        result = _tmp3_;
482
 
        _g_free0 (results);
483
 
        _g_object_unref0 (introspectable);
484
 
        return result;
485
 
        _g_free0 (results);
 
529
        {
 
530
                const gchar* _tmp0_;
 
531
                FreeDesktopIntrospectable* _tmp1_ = NULL;
 
532
                FreeDesktopIntrospectable* _tmp2_;
 
533
                FreeDesktopIntrospectable* _tmp3_;
 
534
                gchar* _tmp4_ = NULL;
 
535
                gchar* results;
 
536
                const gchar* _tmp5_;
 
537
                gboolean _tmp6_ = FALSE;
 
538
                _tmp0_ = name;
 
539
                _tmp1_ = g_initable_new (TYPE_FREE_DESKTOP_INTROSPECTABLE_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "g-name", _tmp0_, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", MPRIS_MEDIA_PLAYER_PATH, "g-interface-name", "org.freedesktop.DBus.Introspectable", NULL);
 
540
                _tmp2_ = (FreeDesktopIntrospectable*) _tmp1_;
 
541
                if (_inner_error_ != NULL) {
 
542
                        if (_inner_error_->domain == G_IO_ERROR) {
 
543
                                goto __catch9_g_io_error;
 
544
                        }
 
545
                        _g_object_unref0 (introspectable);
 
546
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
547
                        g_clear_error (&_inner_error_);
 
548
                        return FALSE;
 
549
                }
 
550
                _g_object_unref0 (introspectable);
 
551
                introspectable = _tmp2_;
 
552
                _tmp3_ = introspectable;
 
553
                _tmp4_ = free_desktop_introspectable_Introspect (_tmp3_, &_inner_error_);
 
554
                results = _tmp4_;
 
555
                if (_inner_error_ != NULL) {
 
556
                        if (_inner_error_->domain == G_IO_ERROR) {
 
557
                                goto __catch9_g_io_error;
 
558
                        }
 
559
                        _g_object_unref0 (introspectable);
 
560
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
561
                        g_clear_error (&_inner_error_);
 
562
                        return FALSE;
 
563
                }
 
564
                _tmp5_ = results;
 
565
                _tmp6_ = mpris2_watcher_parse_interfaces (self, _tmp5_);
 
566
                result = _tmp6_;
 
567
                _g_free0 (results);
 
568
                _g_object_unref0 (introspectable);
 
569
                return result;
 
570
        }
486
571
        goto __finally9;
487
572
        __catch9_g_io_error:
488
573
        {
489
 
                GError * e;
 
574
                GError* e = NULL;
 
575
                GError* _tmp7_;
 
576
                const gchar* _tmp8_;
490
577
                e = _inner_error_;
491
578
                _inner_error_ = NULL;
492
 
                g_warning ("mpris2-watcher.vala:131: Could not create an introspectable object: %s", e->message);
 
579
                _tmp7_ = e;
 
580
                _tmp8_ = _tmp7_->message;
 
581
                g_warning ("mpris2-watcher.vala:131: Could not create an introspectable object: %s", _tmp8_);
493
582
                _g_error_free0 (e);
494
583
        }
495
584
        __finally9:
508
597
static gboolean mpris2_watcher_parse_interfaces (Mpris2Watcher* self, const gchar* interface_info) {
509
598
        gboolean result = FALSE;
510
599
        gboolean _result_;
511
 
        xmlDoc* _tmp0_ = NULL;
 
600
        const gchar* _tmp0_;
 
601
        xmlDoc* _tmp1_ = NULL;
512
602
        xmlDoc* xml_doc;
513
 
        xmlNode* _tmp1_ = NULL;
 
603
        xmlDoc* _tmp2_;
 
604
        xmlDoc* _tmp3_;
 
605
        xmlNode* _tmp4_ = NULL;
514
606
        xmlNode* root_node;
 
607
        xmlNode* _tmp5_;
 
608
        xmlDoc* _tmp27_;
515
609
        g_return_val_if_fail (self != NULL, FALSE);
516
610
        g_return_val_if_fail (interface_info != NULL, FALSE);
517
611
        _result_ = FALSE;
518
 
        _tmp0_ = xmlParseDoc (interface_info);
519
 
        xml_doc = _tmp0_;
520
 
        if (xml_doc == NULL) {
 
612
        _tmp0_ = interface_info;
 
613
        _tmp1_ = xmlParseDoc (_tmp0_);
 
614
        xml_doc = _tmp1_;
 
615
        _tmp2_ = xml_doc;
 
616
        if (_tmp2_ == NULL) {
521
617
                g_warning ("mpris2-watcher.vala:143: Mpris2Watcher - parse-interfaces - failed to " \
522
618
"instantiate xml doc");
523
619
                result = FALSE;
524
620
                return result;
525
621
        }
526
 
        _tmp1_ = xmlDocGetRootElement (xml_doc);
527
 
        root_node = _tmp1_;
528
 
        if (root_node == NULL) {
529
 
                xmlFreeDoc (xml_doc);
 
622
        _tmp3_ = xml_doc;
 
623
        _tmp4_ = xmlDocGetRootElement (_tmp3_);
 
624
        root_node = _tmp4_;
 
625
        _tmp5_ = root_node;
 
626
        if (_tmp5_ == NULL) {
 
627
                xmlDoc* _tmp6_;
 
628
                _tmp6_ = xml_doc;
 
629
                xmlFreeDoc (_tmp6_);
530
630
                g_warning ("mpris2-watcher.vala:151: Mpris2Watcher - the interface info xml is emp" \
531
631
"ty");
532
632
                result = FALSE;
533
633
                return result;
534
634
        }
535
635
        {
 
636
                xmlNode* _tmp7_;
 
637
                xmlNode* _tmp8_;
536
638
                xmlNode* iter;
537
 
                iter = root_node->children;
 
639
                _tmp7_ = root_node;
 
640
                _tmp8_ = _tmp7_->children;
 
641
                iter = _tmp8_;
538
642
                {
539
 
                        gboolean _tmp2_;
540
 
                        _tmp2_ = TRUE;
 
643
                        gboolean _tmp9_;
 
644
                        _tmp9_ = TRUE;
541
645
                        while (TRUE) {
 
646
                                gboolean _tmp10_;
 
647
                                xmlNode* _tmp13_;
 
648
                                xmlNode* _tmp14_;
 
649
                                xmlElementType _tmp15_;
 
650
                                xmlNode* _tmp16_;
 
651
                                xmlAttr* _tmp17_;
542
652
                                xmlAttr* attributes;
543
 
                                gchar* _tmp3_;
 
653
                                xmlAttr* _tmp18_;
 
654
                                xmlNode* _tmp19_;
 
655
                                const gchar* _tmp20_;
 
656
                                gchar* _tmp21_;
544
657
                                gchar* interface_name;
545
 
                                gchar* _tmp4_ = NULL;
546
 
                                gchar* _tmp5_;
547
 
                                gboolean _tmp6_;
548
 
                                if (!_tmp2_) {
549
 
                                        iter = iter->next;
 
658
                                const gchar* _tmp22_;
 
659
                                const gchar* _tmp23_;
 
660
                                gchar* _tmp24_ = NULL;
 
661
                                gchar* _tmp25_;
 
662
                                gboolean _tmp26_;
 
663
                                _tmp10_ = _tmp9_;
 
664
                                if (!_tmp10_) {
 
665
                                        xmlNode* _tmp11_;
 
666
                                        xmlNode* _tmp12_;
 
667
                                        _tmp11_ = iter;
 
668
                                        _tmp12_ = _tmp11_->next;
 
669
                                        iter = _tmp12_;
550
670
                                }
551
 
                                _tmp2_ = FALSE;
552
 
                                if (!(iter != NULL)) {
 
671
                                _tmp9_ = FALSE;
 
672
                                _tmp13_ = iter;
 
673
                                if (!(_tmp13_ != NULL)) {
553
674
                                        break;
554
675
                                }
555
 
                                if (iter->type != XML_ELEMENT_NODE) {
 
676
                                _tmp14_ = iter;
 
677
                                _tmp15_ = _tmp14_->type;
 
678
                                if (_tmp15_ != XML_ELEMENT_NODE) {
556
679
                                        continue;
557
680
                                }
558
 
                                attributes = iter->properties;
559
 
                                _tmp3_ = g_strdup (attributes->children->content);
560
 
                                interface_name = _tmp3_;
561
 
                                g_debug ("mpris2-watcher.vala:163: this dbus object has interface %s ", interface_name);
562
 
                                _tmp4_ = g_strconcat (MPRIS_PREFIX, "Playlists", NULL);
563
 
                                _tmp5_ = _tmp4_;
564
 
                                _tmp6_ = g_strcmp0 (interface_name, _tmp5_) == 0;
565
 
                                _g_free0 (_tmp5_);
566
 
                                if (_tmp6_) {
 
681
                                _tmp16_ = iter;
 
682
                                _tmp17_ = _tmp16_->properties;
 
683
                                attributes = _tmp17_;
 
684
                                _tmp18_ = attributes;
 
685
                                _tmp19_ = _tmp18_->children;
 
686
                                _tmp20_ = _tmp19_->content;
 
687
                                _tmp21_ = g_strdup (_tmp20_);
 
688
                                interface_name = _tmp21_;
 
689
                                _tmp22_ = interface_name;
 
690
                                g_debug ("mpris2-watcher.vala:163: this dbus object has interface %s ", _tmp22_);
 
691
                                _tmp23_ = interface_name;
 
692
                                _tmp24_ = g_strconcat (MPRIS_PREFIX, "Playlists", NULL);
 
693
                                _tmp25_ = _tmp24_;
 
694
                                _tmp26_ = g_strcmp0 (_tmp23_, _tmp25_) == 0;
 
695
                                _g_free0 (_tmp25_);
 
696
                                if (_tmp26_) {
567
697
                                        _result_ = TRUE;
568
698
                                }
569
699
                                _g_free0 (interface_name);
570
700
                        }
571
701
                }
572
702
        }
573
 
        xmlFreeDoc (xml_doc);
 
703
        _tmp27_ = xml_doc;
 
704
        xmlFreeDoc (_tmp27_);
574
705
        result = _result_;
575
706
        return result;
576
707
}
580
711
        typedef void (*GMarshalFunc_VOID__STRING_STRING_BOOLEAN) (gpointer data1, const char* arg_1, const char* arg_2, gboolean arg_3, gpointer data2);
581
712
        register GMarshalFunc_VOID__STRING_STRING_BOOLEAN callback;
582
713
        register GCClosure * cc;
583
 
        register gpointer data1, data2;
 
714
        register gpointer data1;
 
715
        register gpointer data2;
584
716
        cc = (GCClosure *) closure;
585
717
        g_return_if_fail (n_param_values == 4);
586
718
        if (G_CCLOSURE_SWAP_DATA (closure)) {
604
736
        GObject * obj;
605
737
        GObjectClass * parent_class;
606
738
        Mpris2Watcher * self;
607
 
        FreeDesktopObject* _tmp0_ = NULL;
608
 
        FreeDesktopObject* _tmp1_;
609
739
        GError * _inner_error_ = NULL;
610
740
        parent_class = G_OBJECT_CLASS (mpris2_watcher_parent_class);
611
741
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
612
742
        self = MPRIS2_WATCHER (obj);
613
 
        _tmp0_ = g_initable_new (TYPE_FREE_DESKTOP_OBJECT_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "g-name", FREEDESKTOP_SERVICE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", FREEDESKTOP_OBJECT, "g-interface-name", "org.freedesktop.DBus", NULL);
614
 
        _tmp1_ = (FreeDesktopObject*) _tmp0_;
615
 
        if (_inner_error_ != NULL) {
616
 
                if (_inner_error_->domain == G_IO_ERROR) {
617
 
                        goto __catch10_g_io_error;
 
743
        {
 
744
                FreeDesktopObject* _tmp0_ = NULL;
 
745
                FreeDesktopObject* _tmp1_;
 
746
                FreeDesktopObject* _tmp2_;
 
747
                _tmp0_ = g_initable_new (TYPE_FREE_DESKTOP_OBJECT_PROXY, NULL, &_inner_error_, "g-flags", G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, "g-name", FREEDESKTOP_SERVICE, "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", FREEDESKTOP_OBJECT, "g-interface-name", "org.freedesktop.DBus", NULL);
 
748
                _tmp1_ = (FreeDesktopObject*) _tmp0_;
 
749
                if (_inner_error_ != NULL) {
 
750
                        if (_inner_error_->domain == G_IO_ERROR) {
 
751
                                goto __catch10_g_io_error;
 
752
                        }
 
753
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
754
                        g_clear_error (&_inner_error_);
618
755
                }
619
 
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
620
 
                g_clear_error (&_inner_error_);
 
756
                _g_object_unref0 (self->priv->fdesktop_obj);
 
757
                self->priv->fdesktop_obj = _tmp1_;
 
758
                _tmp2_ = self->priv->fdesktop_obj;
 
759
                g_signal_connect_object (_tmp2_, "name-owner-changed", (GCallback) _mpris2_watcher_name_changes_detected_free_desktop_object_name_owner_changed, self, 0);
 
760
                mpris2_watcher_check_for_active_clients (self, NULL, NULL);
621
761
        }
622
 
        _g_object_unref0 (self->priv->fdesktop_obj);
623
 
        self->priv->fdesktop_obj = _tmp1_;
624
 
        g_signal_connect_object (self->priv->fdesktop_obj, "name-owner-changed", (GCallback) _mpris2_watcher_name_changes_detected_free_desktop_object_name_owner_changed, self, 0);
625
 
        mpris2_watcher_check_for_active_clients (self, NULL, NULL);
626
762
        goto __finally10;
627
763
        __catch10_g_io_error:
628
764
        {
629
 
                GError * e;
 
765
                GError* e = NULL;
 
766
                GError* _tmp3_;
 
767
                const gchar* _tmp4_;
630
768
                e = _inner_error_;
631
769
                _inner_error_ = NULL;
 
770
                _tmp3_ = e;
 
771
                _tmp4_ = _tmp3_->message;
632
772
                g_warning ("mpris2-watcher.vala:46: Mpris2watcher could not set up a watch for mpr" \
633
 
"is clients appearing on the bus: %s", e->message);
 
773
"is clients appearing on the bus: %s", _tmp4_);
634
774
                _g_error_free0 (e);
635
775
        }
636
776
        __finally10: