~ubuntu-branches/ubuntu/natty/folks/natty

« back to all changes in this revision

Viewing changes to backends/telepathy/lib/tpf-logger.c

  • Committer: Bazaar Package Importer
  • Author(s): Sjoerd Simons, Laurent Bigonville, Sjoerd Simons
  • Date: 2010-09-01 22:17:28 UTC
  • mfrom: (1.2.2 upstream) (4.1.3 experimental)
  • Revision ID: james.westby@ubuntu.com-20100901221728-k1nz2uzmt26c4acz
Tags: 0.1.16-1
[ Laurent Bigonville ]
* debian/control: Build-depends against valac-0.10 instead of valac

[ Sjoerd Simons ]
* New upstream release
* d/p/0001-tp-lowlevel-doesn-t-actually-depend-upon-the-Gee-int.patch:
  - Removed, merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* tpf-logger.c generated by valac 0.9.7-dirty, the Vala compiler
 
2
 * generated from tpf-logger.vala, do not modify */
 
3
 
 
4
/*
 
5
 * Copyright (C) 2010 Collabora Ltd.
 
6
 *
 
7
 * This library is free software: you can redistribute it and/or modify
 
8
 * it under the terms of the GNU Lesser General Public License as published by
 
9
 * the Free Software Foundation, either version 2.1 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public License
 
18
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
19
 *
 
20
 * Authors:
 
21
 *       Philip Withnall <philip.withnall@collabora.co.uk>
 
22
 */
 
23
 
 
24
#include <glib.h>
 
25
#include <glib-object.h>
 
26
#include <stdlib.h>
 
27
#include <string.h>
 
28
#include <dbus/dbus-glib-lowlevel.h>
 
29
#include <dbus/dbus-glib.h>
 
30
#include <gio/gio.h>
 
31
#include <dbus/dbus.h>
 
32
 
 
33
 
 
34
#define TYPE_ACCOUNT_FAVOURITES (account_favourites_get_type ())
 
35
typedef struct _AccountFavourites AccountFavourites;
 
36
#define _g_free0(var) (var = (g_free (var), NULL))
 
37
 
 
38
#define TYPE_LOGGER_IFACE (logger_iface_get_type ())
 
39
#define LOGGER_IFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LOGGER_IFACE, LoggerIface))
 
40
#define IS_LOGGER_IFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LOGGER_IFACE))
 
41
#define LOGGER_IFACE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_LOGGER_IFACE, LoggerIfaceIface))
 
42
 
 
43
typedef struct _LoggerIface LoggerIface;
 
44
typedef struct _LoggerIfaceIface LoggerIfaceIface;
 
45
typedef struct _DBusObjectVTable _DBusObjectVTable;
 
46
typedef struct _LoggerIfaceDBusProxy LoggerIfaceDBusProxy;
 
47
typedef DBusGProxyClass LoggerIfaceDBusProxyClass;
 
48
typedef struct _LoggerIfaceDBusProxyGetFavouriteContactsData LoggerIfaceDBusProxyGetFavouriteContactsData;
 
49
typedef struct _LoggerIfaceDBusProxyAddFavouriteContactData LoggerIfaceDBusProxyAddFavouriteContactData;
 
50
typedef struct _LoggerIfaceDBusProxyRemoveFavouriteContactData LoggerIfaceDBusProxyRemoveFavouriteContactData;
 
51
 
 
52
#define TYPE_LOGGER (logger_get_type ())
 
53
#define LOGGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LOGGER, Logger))
 
54
#define LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LOGGER, LoggerClass))
 
55
#define IS_LOGGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LOGGER))
 
56
#define IS_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LOGGER))
 
57
#define LOGGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LOGGER, LoggerClass))
 
58
 
 
59
typedef struct _Logger Logger;
 
60
typedef struct _LoggerClass LoggerClass;
 
61
typedef struct _LoggerPrivate LoggerPrivate;
 
62
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
63
#define _dbus_g_connection_unref0(var) ((var == NULL) ? NULL : (var = (dbus_g_connection_unref (var), NULL)))
 
64
typedef struct _LoggerGetFavouriteContactsData LoggerGetFavouriteContactsData;
 
65
typedef struct _LoggerAddFavouriteContactData LoggerAddFavouriteContactData;
 
66
typedef struct _LoggerRemoveFavouriteContactData LoggerRemoveFavouriteContactData;
 
67
 
 
68
struct _AccountFavourites {
 
69
        char* account_path;
 
70
        char** ids;
 
71
        gint ids_length1;
 
72
        gint _ids_size_;
 
73
};
 
74
 
 
75
struct _LoggerIfaceIface {
 
76
        GTypeInterface parent_iface;
 
77
        void (*get_favourite_contacts) (LoggerIface* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
78
        AccountFavourites* (*get_favourite_contacts_finish) (LoggerIface* self, GAsyncResult* _res_, int* result_length1, GError** error);
 
79
        void (*add_favourite_contact) (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
80
        void (*add_favourite_contact_finish) (LoggerIface* self, GAsyncResult* _res_, GError** error);
 
81
        void (*remove_favourite_contact) (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
82
        void (*remove_favourite_contact_finish) (LoggerIface* self, GAsyncResult* _res_, GError** error);
 
83
};
 
84
 
 
85
struct _DBusObjectVTable {
 
86
        void (*register_object) (DBusConnection*, const char*, void*);
 
87
};
 
88
 
 
89
struct _LoggerIfaceDBusProxy {
 
90
        DBusGProxy parent_instance;
 
91
        gboolean disposed;
 
92
};
 
93
 
 
94
struct _LoggerIfaceDBusProxyGetFavouriteContactsData {
 
95
        GAsyncReadyCallback _callback_;
 
96
        gpointer _user_data_;
 
97
        DBusPendingCall* pending;
 
98
};
 
99
 
 
100
struct _LoggerIfaceDBusProxyAddFavouriteContactData {
 
101
        GAsyncReadyCallback _callback_;
 
102
        gpointer _user_data_;
 
103
        DBusPendingCall* pending;
 
104
};
 
105
 
 
106
struct _LoggerIfaceDBusProxyRemoveFavouriteContactData {
 
107
        GAsyncReadyCallback _callback_;
 
108
        gpointer _user_data_;
 
109
        DBusPendingCall* pending;
 
110
};
 
111
 
 
112
struct _Logger {
 
113
        GObject parent_instance;
 
114
        LoggerPrivate * priv;
 
115
};
 
116
 
 
117
struct _LoggerClass {
 
118
        GObjectClass parent_class;
 
119
};
 
120
 
 
121
struct _LoggerPrivate {
 
122
        char* account_path;
 
123
};
 
124
 
 
125
struct _LoggerGetFavouriteContactsData {
 
126
        int _state_;
 
127
        GAsyncResult* _res_;
 
128
        GSimpleAsyncResult* _async_result;
 
129
        Logger* self;
 
130
        char** result;
 
131
        gint result_length1;
 
132
        char** _tmp0_;
 
133
        char** _tmp1_;
 
134
        AccountFavourites* favs;
 
135
        gint _tmp2_;
 
136
        gint favs_length1;
 
137
        gint _favs_size_;
 
138
        AccountFavourites* _tmp3_;
 
139
        char** _tmp4_;
 
140
        char** _tmp5_;
 
141
        AccountFavourites* account_collection;
 
142
        int account_collection_length1;
 
143
        int account_it;
 
144
        AccountFavourites _tmp6_;
 
145
        AccountFavourites account;
 
146
        char** _tmp7_;
 
147
        char** _tmp8_;
 
148
        GError * _inner_error_;
 
149
};
 
150
 
 
151
struct _LoggerAddFavouriteContactData {
 
152
        int _state_;
 
153
        GAsyncResult* _res_;
 
154
        GSimpleAsyncResult* _async_result;
 
155
        Logger* self;
 
156
        char* id;
 
157
        char* _tmp0_;
 
158
        GError * _inner_error_;
 
159
};
 
160
 
 
161
struct _LoggerRemoveFavouriteContactData {
 
162
        int _state_;
 
163
        GAsyncResult* _res_;
 
164
        GSimpleAsyncResult* _async_result;
 
165
        Logger* self;
 
166
        char* id;
 
167
        char* _tmp0_;
 
168
        GError * _inner_error_;
 
169
};
 
170
 
 
171
 
 
172
static LoggerIface* logger_logger;
 
173
static LoggerIface* logger_logger = NULL;
 
174
static gpointer logger_parent_class = NULL;
 
175
 
 
176
GType account_favourites_get_type (void) G_GNUC_CONST;
 
177
AccountFavourites* account_favourites_dup (const AccountFavourites* self);
 
178
void account_favourites_free (AccountFavourites* self);
 
179
void account_favourites_copy (const AccountFavourites* self, AccountFavourites* dest);
 
180
void account_favourites_destroy (AccountFavourites* self);
 
181
static char** _vala_array_dup2 (char** self, int length);
 
182
LoggerIface* logger_iface_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path);
 
183
GType logger_iface_get_type (void) G_GNUC_CONST;
 
184
void logger_iface_get_favourite_contacts (LoggerIface* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
185
AccountFavourites* logger_iface_get_favourite_contacts_finish (LoggerIface* self, GAsyncResult* _res_, int* result_length1, GError** error);
 
186
void logger_iface_add_favourite_contact (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
187
void logger_iface_add_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error);
 
188
void logger_iface_remove_favourite_contact (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
189
void logger_iface_remove_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error);
 
190
static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
191
static void _vala_dbus_unregister_object (gpointer connection, GObject* object);
 
192
void logger_iface_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 
193
void _logger_iface_dbus_unregister (DBusConnection* connection, void* _user_data_);
 
194
DBusHandlerResult logger_iface_dbus_message (DBusConnection* connection, DBusMessage* message, void* object);
 
195
static DBusHandlerResult _dbus_logger_iface_introspect (LoggerIface* self, DBusConnection* connection, DBusMessage* message);
 
196
static DBusHandlerResult _dbus_logger_iface_property_get_all (LoggerIface* self, DBusConnection* connection, DBusMessage* message);
 
197
static void _vala_AccountFavourites_array_free (AccountFavourites* array, gint array_length);
 
198
static DBusHandlerResult _dbus_logger_iface_get_favourite_contacts (LoggerIface* self, DBusConnection* connection, DBusMessage* message);
 
199
static void _dbus_logger_iface_get_favourite_contacts_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
 
200
static DBusHandlerResult _dbus_logger_iface_add_favourite_contact (LoggerIface* self, DBusConnection* connection, DBusMessage* message);
 
201
static void _dbus_logger_iface_add_favourite_contact_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
 
202
static DBusHandlerResult _dbus_logger_iface_remove_favourite_contact (LoggerIface* self, DBusConnection* connection, DBusMessage* message);
 
203
static void _dbus_logger_iface_remove_favourite_contact_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
 
204
static void _dbus_logger_iface_favourite_contacts_changed (GObject* _sender, const char* account_path, char** added, int added_length1, char** removed, int removed_length1, DBusConnection* _connection);
 
205
GType logger_iface_dbus_proxy_get_type (void) G_GNUC_CONST;
 
206
static void _dbus_handle_logger_iface_favourite_contacts_changed (LoggerIface* self, DBusConnection* connection, DBusMessage* message);
 
207
DBusHandlerResult logger_iface_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data);
 
208
enum  {
 
209
        LOGGER_IFACE_DBUS_PROXY_DUMMY_PROPERTY
 
210
};
 
211
static void logger_iface_dbus_proxy_get_favourite_contacts_async (LoggerIface* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
212
static void logger_iface_dbus_proxy_get_favourite_contacts_ready (DBusPendingCall* pending, void* user_data);
 
213
static AccountFavourites* logger_iface_dbus_proxy_get_favourite_contacts_finish (LoggerIface* self, GAsyncResult* _res_, int* result_length1, GError** error);
 
214
static void logger_iface_dbus_proxy_add_favourite_contact_async (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
215
static void logger_iface_dbus_proxy_add_favourite_contact_ready (DBusPendingCall* pending, void* user_data);
 
216
static void logger_iface_dbus_proxy_add_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error);
 
217
static void logger_iface_dbus_proxy_remove_favourite_contact_async (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
218
static void logger_iface_dbus_proxy_remove_favourite_contact_ready (DBusPendingCall* pending, void* user_data);
 
219
static void logger_iface_dbus_proxy_remove_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error);
 
220
static void logger_iface_dbus_proxy_logger_iface__interface_init (LoggerIfaceIface* iface);
 
221
static void logger_iface_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
222
static void logger_iface_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
223
GType logger_get_type (void) G_GNUC_CONST;
 
224
#define LOGGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_LOGGER, LoggerPrivate))
 
225
enum  {
 
226
        LOGGER_DUMMY_PROPERTY
 
227
};
 
228
Logger* logger_new (const char* account_path, GError** error);
 
229
Logger* logger_construct (GType object_type, const char* account_path, GError** error);
 
230
static void _lambda0_ (Logger* self);
 
231
static void __lambda0__dbus_g_proxy_destroy (DBusGProxy* _sender, gpointer self);
 
232
static void _lambda1_ (const char* ap, char** a, int a_length1, char** r, int r_length1, Logger* self);
 
233
static void __lambda1__logger_iface_favourite_contacts_changed (LoggerIface* _sender, const char* account_path, char** added, int added_length1, char** removed, int removed_length1, gpointer self);
 
234
static void logger_get_favourite_contacts_data_free (gpointer _data);
 
235
static void logger_get_favourite_contacts_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
236
void logger_get_favourite_contacts (Logger* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
237
char** logger_get_favourite_contacts_finish (Logger* self, GAsyncResult* _res_, int* result_length1, GError** error);
 
238
static gboolean logger_get_favourite_contacts_co (LoggerGetFavouriteContactsData* data);
 
239
static char** _vala_array_dup3 (char** self, int length);
 
240
static void logger_add_favourite_contact_data_free (gpointer _data);
 
241
static void logger_add_favourite_contact_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
242
void logger_add_favourite_contact (Logger* self, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
243
void logger_add_favourite_contact_finish (Logger* self, GAsyncResult* _res_, GError** error);
 
244
static gboolean logger_add_favourite_contact_co (LoggerAddFavouriteContactData* data);
 
245
static void logger_remove_favourite_contact_data_free (gpointer _data);
 
246
static void logger_remove_favourite_contact_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
247
void logger_remove_favourite_contact (Logger* self, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
248
void logger_remove_favourite_contact_finish (Logger* self, GAsyncResult* _res_, GError** error);
 
249
static gboolean logger_remove_favourite_contact_co (LoggerRemoveFavouriteContactData* data);
 
250
static void logger_finalize (GObject* obj);
 
251
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
252
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
253
static int _vala_strcmp0 (const char * str1, const char * str2);
 
254
 
 
255
static const DBusObjectPathVTable _logger_iface_dbus_path_vtable = {_logger_iface_dbus_unregister, logger_iface_dbus_message};
 
256
static const _DBusObjectVTable _logger_iface_dbus_vtable = {logger_iface_dbus_register_object};
 
257
 
 
258
static void g_cclosure_user_marshal_VOID__BOXED_BOXED_INT_BOXED_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 
259
static void g_cclosure_user_marshal_VOID__BOXED_INT_BOXED_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
 
260
 
 
261
static char** _vala_array_dup2 (char** self, int length) {
 
262
        char** result;
 
263
        int i;
 
264
        result = g_new0 (char*, length + 1);
 
265
        for (i = 0; i < length; i++) {
 
266
                result[i] = g_strdup (self[i]);
 
267
        }
 
268
        return result;
 
269
}
 
270
 
 
271
 
 
272
void account_favourites_copy (const AccountFavourites* self, AccountFavourites* dest) {
 
273
        char** _tmp0_;
 
274
        dest->account_path = g_strdup (self->account_path);
 
275
        dest->ids = (_tmp0_ = self->ids, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup2 (_tmp0_, (*self).ids_length1));
 
276
        dest->ids_length1 = self->ids_length1;
 
277
}
 
278
 
 
279
 
 
280
void account_favourites_destroy (AccountFavourites* self) {
 
281
        _g_free0 (self->account_path);
 
282
        self->ids = (_vala_array_free (self->ids, (*self).ids_length1, (GDestroyNotify) g_free), NULL);
 
283
}
 
284
 
 
285
 
 
286
AccountFavourites* account_favourites_dup (const AccountFavourites* self) {
 
287
        AccountFavourites* dup;
 
288
        dup = g_new0 (AccountFavourites, 1);
 
289
        account_favourites_copy (self, dup);
 
290
        return dup;
 
291
}
 
292
 
 
293
 
 
294
void account_favourites_free (AccountFavourites* self) {
 
295
        account_favourites_destroy (self);
 
296
        g_free (self);
 
297
}
 
298
 
 
299
 
 
300
GType account_favourites_get_type (void) {
 
301
        static volatile gsize account_favourites_type_id__volatile = 0;
 
302
        if (g_once_init_enter (&account_favourites_type_id__volatile)) {
 
303
                GType account_favourites_type_id;
 
304
                account_favourites_type_id = g_boxed_type_register_static ("AccountFavourites", (GBoxedCopyFunc) account_favourites_dup, (GBoxedFreeFunc) account_favourites_free);
 
305
                g_once_init_leave (&account_favourites_type_id__volatile, account_favourites_type_id);
 
306
        }
 
307
        return account_favourites_type_id__volatile;
 
308
}
 
309
 
 
310
 
 
311
void logger_iface_get_favourite_contacts (LoggerIface* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
312
        LOGGER_IFACE_GET_INTERFACE (self)->get_favourite_contacts (self, _callback_, _user_data_);
 
313
}
 
314
 
 
315
 
 
316
AccountFavourites* logger_iface_get_favourite_contacts_finish (LoggerIface* self, GAsyncResult* _res_, int* result_length1, GError** error) {
 
317
        return LOGGER_IFACE_GET_INTERFACE (self)->get_favourite_contacts_finish (self, _res_, result_length1, error);
 
318
}
 
319
 
 
320
 
 
321
void logger_iface_add_favourite_contact (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
322
        LOGGER_IFACE_GET_INTERFACE (self)->add_favourite_contact (self, account_path, id, _callback_, _user_data_);
 
323
}
 
324
 
 
325
 
 
326
void logger_iface_add_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error) {
 
327
        LOGGER_IFACE_GET_INTERFACE (self)->add_favourite_contact_finish (self, _res_, error);
 
328
}
 
329
 
 
330
 
 
331
void logger_iface_remove_favourite_contact (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
332
        LOGGER_IFACE_GET_INTERFACE (self)->remove_favourite_contact (self, account_path, id, _callback_, _user_data_);
 
333
}
 
334
 
 
335
 
 
336
void logger_iface_remove_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error) {
 
337
        LOGGER_IFACE_GET_INTERFACE (self)->remove_favourite_contact_finish (self, _res_, error);
 
338
}
 
339
 
 
340
 
 
341
static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
342
        const _DBusObjectVTable * vtable;
 
343
        vtable = g_type_get_qdata (G_TYPE_FROM_INSTANCE (object), g_quark_from_static_string ("DBusObjectVTable"));
 
344
        if (vtable) {
 
345
                vtable->register_object (connection, path, object);
 
346
        } else {
 
347
                g_warning ("Object does not implement any D-Bus interface");
 
348
        }
 
349
}
 
350
 
 
351
 
 
352
static void _vala_dbus_unregister_object (gpointer connection, GObject* object) {
 
353
        char* path;
 
354
        path = g_object_steal_data ((GObject*) object, "dbus_object_path");
 
355
        dbus_connection_unregister_object_path (connection, path);
 
356
        g_free (path);
 
357
}
 
358
 
 
359
 
 
360
void _logger_iface_dbus_unregister (DBusConnection* connection, void* _user_data_) {
 
361
}
 
362
 
 
363
 
 
364
static DBusHandlerResult _dbus_logger_iface_introspect (LoggerIface* self, DBusConnection* connection, DBusMessage* message) {
 
365
        DBusMessage* reply;
 
366
        DBusMessageIter iter;
 
367
        GString* xml_data;
 
368
        char** children;
 
369
        int i;
 
370
        reply = dbus_message_new_method_return (message);
 
371
        dbus_message_iter_init_append (reply, &iter);
 
372
        xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");
 
373
        g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n  <method name=\"Introspect\">\n    <arg name=\"data\" direction=\"out\" type=\"s\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n  <method name=\"Get\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"out\" type=\"v\"/>\n  </method>\n  <method name=\"Set\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"in\" type=\"v\"/>\n  </method>\n  <method name=\"GetAll\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.Telepathy.Logger.DRAFT\">\n  <method name=\"GetFavouriteContacts\">\n    <arg name=\"result\" type=\"a(oas)\" direction=\"out\"/>\n  </method>\n  <method name=\"AddFavouriteContact\">\n    <arg name=\"account_path\" type=\"o\" direction=\"in\"/>\n    <arg name=\"id\" type=\"s\" direction=\"in\"/>\n  </method>\n  <method name=\"RemoveFavouriteContact\">\n    <arg name=\"account_path\" type=\"o\" direction=\"in\"/>\n    <arg name=\"id\" type=\"s\" direction=\"in\"/>\n  </method>\n  <signal name=\"FavouriteContactsChanged\">\n    <arg name=\"account_path\" type=\"o\"/>\n    <arg name=\"added\" type=\"as\"/>\n    <arg name=\"removed\" type=\"as\"/>\n  </signal>\n</interface>\n");
 
374
        dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);
 
375
        for (i = 0; children[i]; i++) {
 
376
                g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);
 
377
        }
 
378
        dbus_free_string_array (children);
 
379
        g_string_append (xml_data, "</node>\n");
 
380
        dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);
 
381
        g_string_free (xml_data, TRUE);
 
382
        if (reply) {
 
383
                dbus_connection_send (connection, reply, NULL);
 
384
                dbus_message_unref (reply);
 
385
                return DBUS_HANDLER_RESULT_HANDLED;
 
386
        } else {
 
387
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
388
        }
 
389
}
 
390
 
 
391
 
 
392
static DBusHandlerResult _dbus_logger_iface_property_get_all (LoggerIface* self, DBusConnection* connection, DBusMessage* message) {
 
393
        DBusMessage* reply;
 
394
        DBusMessageIter iter, reply_iter, subiter;
 
395
        char* interface_name;
 
396
        const char* _tmp0_;
 
397
        if (strcmp (dbus_message_get_signature (message), "s")) {
 
398
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
399
        }
 
400
        dbus_message_iter_init (message, &iter);
 
401
        reply = dbus_message_new_method_return (message);
 
402
        dbus_message_iter_init_append (reply, &reply_iter);
 
403
        dbus_message_iter_get_basic (&iter, &_tmp0_);
 
404
        dbus_message_iter_next (&iter);
 
405
        interface_name = g_strdup (_tmp0_);
 
406
        if (strcmp (interface_name, "org.freedesktop.Telepathy.Logger.DRAFT") == 0) {
 
407
                dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_ARRAY, "{sv}", &subiter);
 
408
                dbus_message_iter_close_container (&reply_iter, &subiter);
 
409
        } else {
 
410
                dbus_message_unref (reply);
 
411
                reply = NULL;
 
412
        }
 
413
        g_free (interface_name);
 
414
        if (reply) {
 
415
                dbus_connection_send (connection, reply, NULL);
 
416
                dbus_message_unref (reply);
 
417
                return DBUS_HANDLER_RESULT_HANDLED;
 
418
        } else {
 
419
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
420
        }
 
421
}
 
422
 
 
423
 
 
424
static void _vala_AccountFavourites_array_free (AccountFavourites* array, gint array_length) {
 
425
        if (array != NULL) {
 
426
                int i;
 
427
                for (i = 0; i < array_length; i = i + 1) {
 
428
                        account_favourites_destroy (&array[i]);
 
429
                }
 
430
        }
 
431
        g_free (array);
 
432
}
 
433
 
 
434
 
 
435
static DBusHandlerResult _dbus_logger_iface_get_favourite_contacts (LoggerIface* self, DBusConnection* connection, DBusMessage* message) {
 
436
        DBusMessageIter iter;
 
437
        gpointer * _user_data_;
 
438
        if (strcmp (dbus_message_get_signature (message), "")) {
 
439
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
440
        }
 
441
        dbus_message_iter_init (message, &iter);
 
442
        _user_data_ = g_new0 (gpointer, 2);
 
443
        _user_data_[0] = dbus_connection_ref (connection);
 
444
        _user_data_[1] = dbus_message_ref (message);
 
445
        logger_iface_get_favourite_contacts (self, (GAsyncReadyCallback) _dbus_logger_iface_get_favourite_contacts_ready, _user_data_);
 
446
        return DBUS_HANDLER_RESULT_HANDLED;
 
447
}
 
448
 
 
449
 
 
450
static void _dbus_logger_iface_get_favourite_contacts_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
 
451
        DBusConnection * connection;
 
452
        DBusMessage * message;
 
453
        DBusMessageIter iter;
 
454
        GError* error;
 
455
        AccountFavourites* result;
 
456
        int result_length1;
 
457
        DBusMessage* reply;
 
458
        AccountFavourites* _tmp1_;
 
459
        DBusMessageIter _tmp2_;
 
460
        int _tmp3_;
 
461
        connection = _user_data_[0];
 
462
        message = _user_data_[1];
 
463
        error = NULL;
 
464
        result_length1 = 0;
 
465
        result = logger_iface_get_favourite_contacts_finish ((LoggerIface*) source_object, _res_, &result_length1, &error);
 
466
        if (error) {
 
467
                if (error->domain == DBUS_GERROR) {
 
468
                        switch (error->code) {
 
469
                                case DBUS_GERROR_FAILED:
 
470
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
471
                                break;
 
472
                                case DBUS_GERROR_NO_MEMORY:
 
473
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
474
                                break;
 
475
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
476
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
477
                                break;
 
478
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
479
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
480
                                break;
 
481
                                case DBUS_GERROR_NO_REPLY:
 
482
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
483
                                break;
 
484
                                case DBUS_GERROR_IO_ERROR:
 
485
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
486
                                break;
 
487
                                case DBUS_GERROR_BAD_ADDRESS:
 
488
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
489
                                break;
 
490
                                case DBUS_GERROR_NOT_SUPPORTED:
 
491
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
492
                                break;
 
493
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
494
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
495
                                break;
 
496
                                case DBUS_GERROR_ACCESS_DENIED:
 
497
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
498
                                break;
 
499
                                case DBUS_GERROR_AUTH_FAILED:
 
500
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
501
                                break;
 
502
                                case DBUS_GERROR_NO_SERVER:
 
503
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
504
                                break;
 
505
                                case DBUS_GERROR_TIMEOUT:
 
506
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
507
                                break;
 
508
                                case DBUS_GERROR_NO_NETWORK:
 
509
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
510
                                break;
 
511
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
512
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
513
                                break;
 
514
                                case DBUS_GERROR_DISCONNECTED:
 
515
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
516
                                break;
 
517
                                case DBUS_GERROR_INVALID_ARGS:
 
518
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
519
                                break;
 
520
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
521
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
522
                                break;
 
523
                                case DBUS_GERROR_FILE_EXISTS:
 
524
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
525
                                break;
 
526
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
527
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
528
                                break;
 
529
                                case DBUS_GERROR_TIMED_OUT:
 
530
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
531
                                break;
 
532
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
533
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
534
                                break;
 
535
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
536
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
537
                                break;
 
538
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
539
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
540
                                break;
 
541
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
542
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
543
                                break;
 
544
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
545
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
546
                                break;
 
547
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
548
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
549
                                break;
 
550
                                case DBUS_GERROR_SPAWN_FAILED:
 
551
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
552
                                break;
 
553
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
554
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
555
                                break;
 
556
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
557
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
558
                                break;
 
559
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
560
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
561
                                break;
 
562
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
563
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
564
                                break;
 
565
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
566
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
567
                                break;
 
568
                        }
 
569
                }
 
570
                dbus_connection_send (connection, reply, NULL);
 
571
                dbus_message_unref (reply);
 
572
                return;
 
573
        }
 
574
        reply = dbus_message_new_method_return (message);
 
575
        dbus_message_iter_init_append (reply, &iter);
 
576
        _tmp1_ = result;
 
577
        dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(oas)", &_tmp2_);
 
578
        for (_tmp3_ = 0; _tmp3_ < result_length1; _tmp3_++) {
 
579
                DBusMessageIter _tmp4_;
 
580
                const char* _tmp5_;
 
581
                char** _tmp6_;
 
582
                DBusMessageIter _tmp7_;
 
583
                int _tmp8_;
 
584
                dbus_message_iter_open_container (&_tmp2_, DBUS_TYPE_STRUCT, NULL, &_tmp4_);
 
585
                _tmp5_ = (*_tmp1_).account_path;
 
586
                dbus_message_iter_append_basic (&_tmp4_, DBUS_TYPE_OBJECT_PATH, &_tmp5_);
 
587
                _tmp6_ = (*_tmp1_).ids;
 
588
                dbus_message_iter_open_container (&_tmp4_, DBUS_TYPE_ARRAY, "s", &_tmp7_);
 
589
                for (_tmp8_ = 0; _tmp8_ < (*_tmp1_).ids_length1; _tmp8_++) {
 
590
                        const char* _tmp9_;
 
591
                        _tmp9_ = *_tmp6_;
 
592
                        dbus_message_iter_append_basic (&_tmp7_, DBUS_TYPE_STRING, &_tmp9_);
 
593
                        _tmp6_++;
 
594
                }
 
595
                dbus_message_iter_close_container (&_tmp4_, &_tmp7_);
 
596
                dbus_message_iter_close_container (&_tmp2_, &_tmp4_);
 
597
                _tmp1_++;
 
598
        }
 
599
        dbus_message_iter_close_container (&iter, &_tmp2_);
 
600
        result = (_vala_AccountFavourites_array_free (result,  result_length1), NULL);
 
601
        dbus_connection_send (connection, reply, NULL);
 
602
        dbus_message_unref (reply);
 
603
        dbus_connection_unref (connection);
 
604
        dbus_message_unref (message);
 
605
        g_free (_user_data_);
 
606
}
 
607
 
 
608
 
 
609
static DBusHandlerResult _dbus_logger_iface_add_favourite_contact (LoggerIface* self, DBusConnection* connection, DBusMessage* message) {
 
610
        DBusMessageIter iter;
 
611
        char* account_path = NULL;
 
612
        const char* _tmp10_;
 
613
        char* id = NULL;
 
614
        const char* _tmp11_;
 
615
        gpointer * _user_data_;
 
616
        if (strcmp (dbus_message_get_signature (message), "os")) {
 
617
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
618
        }
 
619
        dbus_message_iter_init (message, &iter);
 
620
        dbus_message_iter_get_basic (&iter, &_tmp10_);
 
621
        dbus_message_iter_next (&iter);
 
622
        account_path = g_strdup (_tmp10_);
 
623
        dbus_message_iter_get_basic (&iter, &_tmp11_);
 
624
        dbus_message_iter_next (&iter);
 
625
        id = g_strdup (_tmp11_);
 
626
        _user_data_ = g_new0 (gpointer, 2);
 
627
        _user_data_[0] = dbus_connection_ref (connection);
 
628
        _user_data_[1] = dbus_message_ref (message);
 
629
        logger_iface_add_favourite_contact (self, account_path, id, (GAsyncReadyCallback) _dbus_logger_iface_add_favourite_contact_ready, _user_data_);
 
630
        _g_free0 (account_path);
 
631
        _g_free0 (id);
 
632
        return DBUS_HANDLER_RESULT_HANDLED;
 
633
}
 
634
 
 
635
 
 
636
static void _dbus_logger_iface_add_favourite_contact_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
 
637
        DBusConnection * connection;
 
638
        DBusMessage * message;
 
639
        DBusMessageIter iter;
 
640
        GError* error;
 
641
        DBusMessage* reply;
 
642
        connection = _user_data_[0];
 
643
        message = _user_data_[1];
 
644
        error = NULL;
 
645
        logger_iface_add_favourite_contact_finish ((LoggerIface*) source_object, _res_, &error);
 
646
        if (error) {
 
647
                if (error->domain == DBUS_GERROR) {
 
648
                        switch (error->code) {
 
649
                                case DBUS_GERROR_FAILED:
 
650
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
651
                                break;
 
652
                                case DBUS_GERROR_NO_MEMORY:
 
653
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
654
                                break;
 
655
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
656
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
657
                                break;
 
658
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
659
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
660
                                break;
 
661
                                case DBUS_GERROR_NO_REPLY:
 
662
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
663
                                break;
 
664
                                case DBUS_GERROR_IO_ERROR:
 
665
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
666
                                break;
 
667
                                case DBUS_GERROR_BAD_ADDRESS:
 
668
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
669
                                break;
 
670
                                case DBUS_GERROR_NOT_SUPPORTED:
 
671
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
672
                                break;
 
673
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
674
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
675
                                break;
 
676
                                case DBUS_GERROR_ACCESS_DENIED:
 
677
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
678
                                break;
 
679
                                case DBUS_GERROR_AUTH_FAILED:
 
680
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
681
                                break;
 
682
                                case DBUS_GERROR_NO_SERVER:
 
683
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
684
                                break;
 
685
                                case DBUS_GERROR_TIMEOUT:
 
686
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
687
                                break;
 
688
                                case DBUS_GERROR_NO_NETWORK:
 
689
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
690
                                break;
 
691
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
692
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
693
                                break;
 
694
                                case DBUS_GERROR_DISCONNECTED:
 
695
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
696
                                break;
 
697
                                case DBUS_GERROR_INVALID_ARGS:
 
698
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
699
                                break;
 
700
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
701
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
702
                                break;
 
703
                                case DBUS_GERROR_FILE_EXISTS:
 
704
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
705
                                break;
 
706
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
707
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
708
                                break;
 
709
                                case DBUS_GERROR_TIMED_OUT:
 
710
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
711
                                break;
 
712
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
713
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
714
                                break;
 
715
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
716
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
717
                                break;
 
718
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
719
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
720
                                break;
 
721
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
722
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
723
                                break;
 
724
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
725
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
726
                                break;
 
727
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
728
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
729
                                break;
 
730
                                case DBUS_GERROR_SPAWN_FAILED:
 
731
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
732
                                break;
 
733
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
734
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
735
                                break;
 
736
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
737
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
738
                                break;
 
739
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
740
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
741
                                break;
 
742
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
743
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
744
                                break;
 
745
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
746
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
747
                                break;
 
748
                        }
 
749
                }
 
750
                dbus_connection_send (connection, reply, NULL);
 
751
                dbus_message_unref (reply);
 
752
                return;
 
753
        }
 
754
        reply = dbus_message_new_method_return (message);
 
755
        dbus_message_iter_init_append (reply, &iter);
 
756
        dbus_connection_send (connection, reply, NULL);
 
757
        dbus_message_unref (reply);
 
758
        dbus_connection_unref (connection);
 
759
        dbus_message_unref (message);
 
760
        g_free (_user_data_);
 
761
}
 
762
 
 
763
 
 
764
static DBusHandlerResult _dbus_logger_iface_remove_favourite_contact (LoggerIface* self, DBusConnection* connection, DBusMessage* message) {
 
765
        DBusMessageIter iter;
 
766
        char* account_path = NULL;
 
767
        const char* _tmp12_;
 
768
        char* id = NULL;
 
769
        const char* _tmp13_;
 
770
        gpointer * _user_data_;
 
771
        if (strcmp (dbus_message_get_signature (message), "os")) {
 
772
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
773
        }
 
774
        dbus_message_iter_init (message, &iter);
 
775
        dbus_message_iter_get_basic (&iter, &_tmp12_);
 
776
        dbus_message_iter_next (&iter);
 
777
        account_path = g_strdup (_tmp12_);
 
778
        dbus_message_iter_get_basic (&iter, &_tmp13_);
 
779
        dbus_message_iter_next (&iter);
 
780
        id = g_strdup (_tmp13_);
 
781
        _user_data_ = g_new0 (gpointer, 2);
 
782
        _user_data_[0] = dbus_connection_ref (connection);
 
783
        _user_data_[1] = dbus_message_ref (message);
 
784
        logger_iface_remove_favourite_contact (self, account_path, id, (GAsyncReadyCallback) _dbus_logger_iface_remove_favourite_contact_ready, _user_data_);
 
785
        _g_free0 (account_path);
 
786
        _g_free0 (id);
 
787
        return DBUS_HANDLER_RESULT_HANDLED;
 
788
}
 
789
 
 
790
 
 
791
static void _dbus_logger_iface_remove_favourite_contact_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
 
792
        DBusConnection * connection;
 
793
        DBusMessage * message;
 
794
        DBusMessageIter iter;
 
795
        GError* error;
 
796
        DBusMessage* reply;
 
797
        connection = _user_data_[0];
 
798
        message = _user_data_[1];
 
799
        error = NULL;
 
800
        logger_iface_remove_favourite_contact_finish ((LoggerIface*) source_object, _res_, &error);
 
801
        if (error) {
 
802
                if (error->domain == DBUS_GERROR) {
 
803
                        switch (error->code) {
 
804
                                case DBUS_GERROR_FAILED:
 
805
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Failed", error->message);
 
806
                                break;
 
807
                                case DBUS_GERROR_NO_MEMORY:
 
808
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoMemory", error->message);
 
809
                                break;
 
810
                                case DBUS_GERROR_SERVICE_UNKNOWN:
 
811
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.ServiceUnknown", error->message);
 
812
                                break;
 
813
                                case DBUS_GERROR_NAME_HAS_NO_OWNER:
 
814
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NameHasNoOwner", error->message);
 
815
                                break;
 
816
                                case DBUS_GERROR_NO_REPLY:
 
817
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoReply", error->message);
 
818
                                break;
 
819
                                case DBUS_GERROR_IO_ERROR:
 
820
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.IOError", error->message);
 
821
                                break;
 
822
                                case DBUS_GERROR_BAD_ADDRESS:
 
823
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.BadAddress", error->message);
 
824
                                break;
 
825
                                case DBUS_GERROR_NOT_SUPPORTED:
 
826
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NotSupported", error->message);
 
827
                                break;
 
828
                                case DBUS_GERROR_LIMITS_EXCEEDED:
 
829
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.LimitsExceeded", error->message);
 
830
                                break;
 
831
                                case DBUS_GERROR_ACCESS_DENIED:
 
832
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AccessDenied", error->message);
 
833
                                break;
 
834
                                case DBUS_GERROR_AUTH_FAILED:
 
835
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AuthFailed", error->message);
 
836
                                break;
 
837
                                case DBUS_GERROR_NO_SERVER:
 
838
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoServer", error->message);
 
839
                                break;
 
840
                                case DBUS_GERROR_TIMEOUT:
 
841
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Timeout", error->message);
 
842
                                break;
 
843
                                case DBUS_GERROR_NO_NETWORK:
 
844
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.NoNetwork", error->message);
 
845
                                break;
 
846
                                case DBUS_GERROR_ADDRESS_IN_USE:
 
847
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.AddressInUse", error->message);
 
848
                                break;
 
849
                                case DBUS_GERROR_DISCONNECTED:
 
850
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Disconnected", error->message);
 
851
                                break;
 
852
                                case DBUS_GERROR_INVALID_ARGS:
 
853
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidArgs", error->message);
 
854
                                break;
 
855
                                case DBUS_GERROR_FILE_NOT_FOUND:
 
856
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileNotFound", error->message);
 
857
                                break;
 
858
                                case DBUS_GERROR_FILE_EXISTS:
 
859
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.FileExists", error->message);
 
860
                                break;
 
861
                                case DBUS_GERROR_UNKNOWN_METHOD:
 
862
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnknownMethod", error->message);
 
863
                                break;
 
864
                                case DBUS_GERROR_TIMED_OUT:
 
865
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.TimedOut", error->message);
 
866
                                break;
 
867
                                case DBUS_GERROR_MATCH_RULE_NOT_FOUND:
 
868
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleNotFound", error->message);
 
869
                                break;
 
870
                                case DBUS_GERROR_MATCH_RULE_INVALID:
 
871
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.MatchRuleInvalid", error->message);
 
872
                                break;
 
873
                                case DBUS_GERROR_SPAWN_EXEC_FAILED:
 
874
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ExecFailed", error->message);
 
875
                                break;
 
876
                                case DBUS_GERROR_SPAWN_FORK_FAILED:
 
877
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ForkFailed", error->message);
 
878
                                break;
 
879
                                case DBUS_GERROR_SPAWN_CHILD_EXITED:
 
880
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildExited", error->message);
 
881
                                break;
 
882
                                case DBUS_GERROR_SPAWN_CHILD_SIGNALED:
 
883
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.ChildSignaled", error->message);
 
884
                                break;
 
885
                                case DBUS_GERROR_SPAWN_FAILED:
 
886
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.Spawn.Failed", error->message);
 
887
                                break;
 
888
                                case DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN:
 
889
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.UnixProcessIdUnknown", error->message);
 
890
                                break;
 
891
                                case DBUS_GERROR_INVALID_SIGNATURE:
 
892
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidSignature", error->message);
 
893
                                break;
 
894
                                case DBUS_GERROR_INVALID_FILE_CONTENT:
 
895
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.InvalidFileContent", error->message);
 
896
                                break;
 
897
                                case DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN:
 
898
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown", error->message);
 
899
                                break;
 
900
                                case DBUS_GERROR_REMOTE_EXCEPTION:
 
901
                                reply = dbus_message_new_error (message, "org.freedesktop.DBus.Error.RemoteException", error->message);
 
902
                                break;
 
903
                        }
 
904
                }
 
905
                dbus_connection_send (connection, reply, NULL);
 
906
                dbus_message_unref (reply);
 
907
                return;
 
908
        }
 
909
        reply = dbus_message_new_method_return (message);
 
910
        dbus_message_iter_init_append (reply, &iter);
 
911
        dbus_connection_send (connection, reply, NULL);
 
912
        dbus_message_unref (reply);
 
913
        dbus_connection_unref (connection);
 
914
        dbus_message_unref (message);
 
915
        g_free (_user_data_);
 
916
}
 
917
 
 
918
 
 
919
DBusHandlerResult logger_iface_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {
 
920
        DBusHandlerResult result;
 
921
        result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
922
        if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 
923
                result = _dbus_logger_iface_introspect (object, connection, message);
 
924
        } else if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Properties", "GetAll")) {
 
925
                result = _dbus_logger_iface_property_get_all (object, connection, message);
 
926
        } else if (dbus_message_is_method_call (message, "org.freedesktop.Telepathy.Logger.DRAFT", "GetFavouriteContacts")) {
 
927
                result = _dbus_logger_iface_get_favourite_contacts (object, connection, message);
 
928
        } else if (dbus_message_is_method_call (message, "org.freedesktop.Telepathy.Logger.DRAFT", "AddFavouriteContact")) {
 
929
                result = _dbus_logger_iface_add_favourite_contact (object, connection, message);
 
930
        } else if (dbus_message_is_method_call (message, "org.freedesktop.Telepathy.Logger.DRAFT", "RemoveFavouriteContact")) {
 
931
                result = _dbus_logger_iface_remove_favourite_contact (object, connection, message);
 
932
        }
 
933
        if (result == DBUS_HANDLER_RESULT_HANDLED) {
 
934
                return result;
 
935
        } else {
 
936
                return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
937
        }
 
938
}
 
939
 
 
940
 
 
941
static void _dbus_logger_iface_favourite_contacts_changed (GObject* _sender, const char* account_path, char** added, int added_length1, char** removed, int removed_length1, DBusConnection* _connection) {
 
942
        const char * _path;
 
943
        DBusMessage *_message;
 
944
        DBusMessageIter _iter;
 
945
        const char* _tmp14_;
 
946
        char** _tmp15_;
 
947
        DBusMessageIter _tmp16_;
 
948
        int _tmp17_;
 
949
        char** _tmp19_;
 
950
        DBusMessageIter _tmp20_;
 
951
        int _tmp21_;
 
952
        _path = g_object_get_data (_sender, "dbus_object_path");
 
953
        _message = dbus_message_new_signal (_path, "org.freedesktop.Telepathy.Logger.DRAFT", "FavouriteContactsChanged");
 
954
        dbus_message_iter_init_append (_message, &_iter);
 
955
        _tmp14_ = account_path;
 
956
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_OBJECT_PATH, &_tmp14_);
 
957
        _tmp15_ = added;
 
958
        dbus_message_iter_open_container (&_iter, DBUS_TYPE_ARRAY, "s", &_tmp16_);
 
959
        for (_tmp17_ = 0; _tmp17_ < added_length1; _tmp17_++) {
 
960
                const char* _tmp18_;
 
961
                _tmp18_ = *_tmp15_;
 
962
                dbus_message_iter_append_basic (&_tmp16_, DBUS_TYPE_STRING, &_tmp18_);
 
963
                _tmp15_++;
 
964
        }
 
965
        dbus_message_iter_close_container (&_iter, &_tmp16_);
 
966
        _tmp19_ = removed;
 
967
        dbus_message_iter_open_container (&_iter, DBUS_TYPE_ARRAY, "s", &_tmp20_);
 
968
        for (_tmp21_ = 0; _tmp21_ < removed_length1; _tmp21_++) {
 
969
                const char* _tmp22_;
 
970
                _tmp22_ = *_tmp19_;
 
971
                dbus_message_iter_append_basic (&_tmp20_, DBUS_TYPE_STRING, &_tmp22_);
 
972
                _tmp19_++;
 
973
        }
 
974
        dbus_message_iter_close_container (&_iter, &_tmp20_);
 
975
        dbus_connection_send (_connection, _message, NULL);
 
976
        dbus_message_unref (_message);
 
977
}
 
978
 
 
979
 
 
980
void logger_iface_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 
981
        if (!g_object_get_data (object, "dbus_object_path")) {
 
982
                g_object_set_data (object, "dbus_object_path", g_strdup (path));
 
983
                dbus_connection_register_object_path (connection, path, &_logger_iface_dbus_path_vtable, object);
 
984
                g_object_weak_ref (object, _vala_dbus_unregister_object, connection);
 
985
        }
 
986
        g_signal_connect (object, "favourite-contacts-changed", (GCallback) _dbus_logger_iface_favourite_contacts_changed, connection);
 
987
}
 
988
 
 
989
 
 
990
static void logger_iface_base_init (LoggerIfaceIface * iface) {
 
991
        static gboolean initialized = FALSE;
 
992
        if (!initialized) {
 
993
                initialized = TRUE;
 
994
                g_signal_new ("favourite_contacts_changed", TYPE_LOGGER_IFACE, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__BOXED_BOXED_INT_BOXED_INT, G_TYPE_NONE, 5, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRV, G_TYPE_INT, G_TYPE_STRV, G_TYPE_INT);
 
995
                g_type_set_qdata (TYPE_LOGGER_IFACE, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_logger_iface_dbus_vtable));
 
996
        }
 
997
}
 
998
 
 
999
 
 
1000
GType logger_iface_get_type (void) {
 
1001
        static volatile gsize logger_iface_type_id__volatile = 0;
 
1002
        if (g_once_init_enter (&logger_iface_type_id__volatile)) {
 
1003
                static const GTypeInfo g_define_type_info = { sizeof (LoggerIfaceIface), (GBaseInitFunc) logger_iface_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
 
1004
                GType logger_iface_type_id;
 
1005
                logger_iface_type_id = g_type_register_static (G_TYPE_INTERFACE, "LoggerIface", &g_define_type_info, 0);
 
1006
                g_type_interface_add_prerequisite (logger_iface_type_id, DBUS_TYPE_G_PROXY);
 
1007
                g_type_set_qdata (logger_iface_type_id, g_quark_from_string ("ValaDBusInterfaceProxyType"), &logger_iface_dbus_proxy_get_type);
 
1008
                g_once_init_leave (&logger_iface_type_id__volatile, logger_iface_type_id);
 
1009
        }
 
1010
        return logger_iface_type_id__volatile;
 
1011
}
 
1012
 
 
1013
 
 
1014
G_DEFINE_TYPE_EXTENDED (LoggerIfaceDBusProxy, logger_iface_dbus_proxy, DBUS_TYPE_G_PROXY, 0, G_IMPLEMENT_INTERFACE (TYPE_LOGGER_IFACE, logger_iface_dbus_proxy_logger_iface__interface_init) );
 
1015
LoggerIface* logger_iface_dbus_proxy_new (DBusGConnection* connection, const char* name, const char* path) {
 
1016
        LoggerIface* self;
 
1017
        self = g_object_new (logger_iface_dbus_proxy_get_type (), "connection", connection, "name", name, "path", path, "interface", "org.freedesktop.Telepathy.Logger.DRAFT", NULL);
 
1018
        return self;
 
1019
}
 
1020
 
 
1021
 
 
1022
static GObject* logger_iface_dbus_proxy_construct (GType gtype, guint n_properties, GObjectConstructParam* properties) {
 
1023
        GObject* self;
 
1024
        DBusGConnection *connection;
 
1025
        char* path;
 
1026
        char* filter;
 
1027
        self = G_OBJECT_CLASS (logger_iface_dbus_proxy_parent_class)->constructor (gtype, n_properties, properties);
 
1028
        g_object_get (self, "connection", &connection, NULL);
 
1029
        g_object_get (self, "path", &path, NULL);
 
1030
        dbus_connection_add_filter (dbus_g_connection_get_connection (connection), logger_iface_dbus_proxy_filter, self, NULL);
 
1031
        filter = g_strdup_printf ("type='signal',path='%s'", path);
 
1032
        dbus_bus_add_match (dbus_g_connection_get_connection (connection), filter, NULL);
 
1033
        dbus_g_connection_unref (connection);
 
1034
        g_free (path);
 
1035
        g_free (filter);
 
1036
        return self;
 
1037
}
 
1038
 
 
1039
 
 
1040
static void _dbus_handle_logger_iface_favourite_contacts_changed (LoggerIface* self, DBusConnection* connection, DBusMessage* message) {
 
1041
        DBusMessageIter iter;
 
1042
        char* account_path = NULL;
 
1043
        const char* _tmp0_;
 
1044
        char** added = NULL;
 
1045
        int added_length1;
 
1046
        char** _tmp1_;
 
1047
        int _tmp1__length;
 
1048
        int _tmp1__size;
 
1049
        int _tmp1__length1;
 
1050
        DBusMessageIter _tmp2_;
 
1051
        char** removed = NULL;
 
1052
        int removed_length1;
 
1053
        char** _tmp4_;
 
1054
        int _tmp4__length;
 
1055
        int _tmp4__size;
 
1056
        int _tmp4__length1;
 
1057
        DBusMessageIter _tmp5_;
 
1058
        DBusMessage* reply;
 
1059
        if (strcmp (dbus_message_get_signature (message), "oasas")) {
 
1060
                return;
 
1061
        }
 
1062
        dbus_message_iter_init (message, &iter);
 
1063
        dbus_message_iter_get_basic (&iter, &_tmp0_);
 
1064
        dbus_message_iter_next (&iter);
 
1065
        account_path = g_strdup (_tmp0_);
 
1066
        added_length1 = 0;
 
1067
        _tmp1_ = g_new (char*, 5);
 
1068
        _tmp1__length = 0;
 
1069
        _tmp1__size = 4;
 
1070
        _tmp1__length1 = 0;
 
1071
        dbus_message_iter_recurse (&iter, &_tmp2_);
 
1072
        for (; dbus_message_iter_get_arg_type (&_tmp2_); _tmp1__length1++) {
 
1073
                const char* _tmp3_;
 
1074
                if (_tmp1__size == _tmp1__length) {
 
1075
                        _tmp1__size = 2 * _tmp1__size;
 
1076
                        _tmp1_ = g_renew (char*, _tmp1_, _tmp1__size + 1);
 
1077
                }
 
1078
                dbus_message_iter_get_basic (&_tmp2_, &_tmp3_);
 
1079
                dbus_message_iter_next (&_tmp2_);
 
1080
                _tmp1_[_tmp1__length++] = g_strdup (_tmp3_);
 
1081
        }
 
1082
        added_length1 = _tmp1__length1;
 
1083
        _tmp1_[_tmp1__length] = NULL;
 
1084
        dbus_message_iter_next (&iter);
 
1085
        added = _tmp1_;
 
1086
        removed_length1 = 0;
 
1087
        _tmp4_ = g_new (char*, 5);
 
1088
        _tmp4__length = 0;
 
1089
        _tmp4__size = 4;
 
1090
        _tmp4__length1 = 0;
 
1091
        dbus_message_iter_recurse (&iter, &_tmp5_);
 
1092
        for (; dbus_message_iter_get_arg_type (&_tmp5_); _tmp4__length1++) {
 
1093
                const char* _tmp6_;
 
1094
                if (_tmp4__size == _tmp4__length) {
 
1095
                        _tmp4__size = 2 * _tmp4__size;
 
1096
                        _tmp4_ = g_renew (char*, _tmp4_, _tmp4__size + 1);
 
1097
                }
 
1098
                dbus_message_iter_get_basic (&_tmp5_, &_tmp6_);
 
1099
                dbus_message_iter_next (&_tmp5_);
 
1100
                _tmp4_[_tmp4__length++] = g_strdup (_tmp6_);
 
1101
        }
 
1102
        removed_length1 = _tmp4__length1;
 
1103
        _tmp4_[_tmp4__length] = NULL;
 
1104
        dbus_message_iter_next (&iter);
 
1105
        removed = _tmp4_;
 
1106
        g_signal_emit_by_name (self, "favourite-contacts-changed", account_path, added, added_length1, removed, removed_length1);
 
1107
        _g_free0 (account_path);
 
1108
        added = (_vala_array_free (added, added_length1, (GDestroyNotify) g_free), NULL);
 
1109
        removed = (_vala_array_free (removed, removed_length1, (GDestroyNotify) g_free), NULL);
 
1110
}
 
1111
 
 
1112
 
 
1113
DBusHandlerResult logger_iface_dbus_proxy_filter (DBusConnection* connection, DBusMessage* message, void* user_data) {
 
1114
        if (dbus_message_has_path (message, dbus_g_proxy_get_path (user_data))) {
 
1115
                if (dbus_message_is_signal (message, "org.freedesktop.Telepathy.Logger.DRAFT", "FavouriteContactsChanged")) {
 
1116
                        _dbus_handle_logger_iface_favourite_contacts_changed (user_data, connection, message);
 
1117
                }
 
1118
        }
 
1119
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 
1120
}
 
1121
 
 
1122
 
 
1123
static void logger_iface_dbus_proxy_dispose (GObject* self) {
 
1124
        DBusGConnection *connection;
 
1125
        if (((LoggerIfaceDBusProxy*) self)->disposed) {
 
1126
                return;
 
1127
        }
 
1128
        ((LoggerIfaceDBusProxy*) self)->disposed = TRUE;
 
1129
        g_object_get (self, "connection", &connection, NULL);
 
1130
        dbus_connection_remove_filter (dbus_g_connection_get_connection (connection), logger_iface_dbus_proxy_filter, self);
 
1131
        G_OBJECT_CLASS (logger_iface_dbus_proxy_parent_class)->dispose (self);
 
1132
}
 
1133
 
 
1134
 
 
1135
static void logger_iface_dbus_proxy_class_init (LoggerIfaceDBusProxyClass* klass) {
 
1136
        G_OBJECT_CLASS (klass)->constructor = logger_iface_dbus_proxy_construct;
 
1137
        G_OBJECT_CLASS (klass)->dispose = logger_iface_dbus_proxy_dispose;
 
1138
        G_OBJECT_CLASS (klass)->get_property = logger_iface_dbus_proxy_get_property;
 
1139
        G_OBJECT_CLASS (klass)->set_property = logger_iface_dbus_proxy_set_property;
 
1140
}
 
1141
 
 
1142
 
 
1143
static void logger_iface_dbus_proxy_init (LoggerIfaceDBusProxy* self) {
 
1144
}
 
1145
 
 
1146
 
 
1147
static void logger_iface_dbus_proxy_get_favourite_contacts_async (LoggerIface* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1148
        DBusGConnection *_connection;
 
1149
        DBusMessage *_message;
 
1150
        DBusPendingCall *_pending;
 
1151
        DBusMessageIter _iter;
 
1152
        LoggerIfaceDBusProxyGetFavouriteContactsData* _data_;
 
1153
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.Telepathy.Logger.DRAFT", "GetFavouriteContacts");
 
1154
        dbus_message_iter_init_append (_message, &_iter);
 
1155
        g_object_get (self, "connection", &_connection, NULL);
 
1156
        dbus_connection_send_with_reply (dbus_g_connection_get_connection (_connection), _message, &_pending, -1);
 
1157
        dbus_g_connection_unref (_connection);
 
1158
        dbus_message_unref (_message);
 
1159
        _data_ = g_slice_new0 (LoggerIfaceDBusProxyGetFavouriteContactsData);
 
1160
        _data_->_callback_ = _callback_;
 
1161
        _data_->_user_data_ = _user_data_;
 
1162
        _data_->pending = _pending;
 
1163
        dbus_pending_call_set_notify (_pending, logger_iface_dbus_proxy_get_favourite_contacts_ready, _data_, NULL);
 
1164
}
 
1165
 
 
1166
 
 
1167
static void logger_iface_dbus_proxy_get_favourite_contacts_ready (DBusPendingCall* pending, void* user_data) {
 
1168
        LoggerIfaceDBusProxyGetFavouriteContactsData* _data_;
 
1169
        GObject * _obj_;
 
1170
        GSimpleAsyncResult * _res_;
 
1171
        _data_ = user_data;
 
1172
        _obj_ = g_object_newv (G_TYPE_OBJECT, 0, NULL);
 
1173
        _res_ = g_simple_async_result_new (_obj_, _data_->_callback_, _data_->_user_data_, _data_);
 
1174
        g_simple_async_result_complete (_res_);
 
1175
        g_object_unref (_obj_);
 
1176
        g_object_unref (_res_);
 
1177
        g_slice_free (LoggerIfaceDBusProxyGetFavouriteContactsData, _data_);
 
1178
        dbus_pending_call_unref (pending);
 
1179
}
 
1180
 
 
1181
 
 
1182
static AccountFavourites* logger_iface_dbus_proxy_get_favourite_contacts_finish (LoggerIface* self, GAsyncResult* _res_, int* result_length1, GError** error) {
 
1183
        LoggerIfaceDBusProxyGetFavouriteContactsData* _data_;
 
1184
        DBusError _dbus_error;
 
1185
        DBusMessage *_reply;
 
1186
        DBusMessageIter _iter;
 
1187
        AccountFavourites* _result;
 
1188
        int _result_length1;
 
1189
        AccountFavourites* _tmp16_;
 
1190
        int _tmp16__length;
 
1191
        int _tmp16__size;
 
1192
        int _tmp16__length1;
 
1193
        DBusMessageIter _tmp17_;
 
1194
        _data_ = g_simple_async_result_get_source_tag ((GSimpleAsyncResult *) _res_);
 
1195
        dbus_error_init (&_dbus_error);
 
1196
        _reply = dbus_pending_call_steal_reply (_data_->pending);
 
1197
        dbus_set_error_from_message (&_dbus_error, _reply);
 
1198
        if (dbus_error_is_set (&_dbus_error)) {
 
1199
                GQuark _edomain;
 
1200
                gint _ecode;
 
1201
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
1202
                        const char* _tmp15_;
 
1203
                        _edomain = DBUS_GERROR;
 
1204
                        _tmp15_ = _dbus_error.name + 27;
 
1205
                        if (strcmp (_tmp15_, "Failed") == 0) {
 
1206
                                _ecode = DBUS_GERROR_FAILED;
 
1207
                        } else if (strcmp (_tmp15_, "NoMemory") == 0) {
 
1208
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
1209
                        } else if (strcmp (_tmp15_, "ServiceUnknown") == 0) {
 
1210
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
1211
                        } else if (strcmp (_tmp15_, "NameHasNoOwner") == 0) {
 
1212
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
1213
                        } else if (strcmp (_tmp15_, "NoReply") == 0) {
 
1214
                                _ecode = DBUS_GERROR_NO_REPLY;
 
1215
                        } else if (strcmp (_tmp15_, "IOError") == 0) {
 
1216
                                _ecode = DBUS_GERROR_IO_ERROR;
 
1217
                        } else if (strcmp (_tmp15_, "BadAddress") == 0) {
 
1218
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
1219
                        } else if (strcmp (_tmp15_, "NotSupported") == 0) {
 
1220
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
1221
                        } else if (strcmp (_tmp15_, "LimitsExceeded") == 0) {
 
1222
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
1223
                        } else if (strcmp (_tmp15_, "AccessDenied") == 0) {
 
1224
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
1225
                        } else if (strcmp (_tmp15_, "AuthFailed") == 0) {
 
1226
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
1227
                        } else if (strcmp (_tmp15_, "NoServer") == 0) {
 
1228
                                _ecode = DBUS_GERROR_NO_SERVER;
 
1229
                        } else if (strcmp (_tmp15_, "Timeout") == 0) {
 
1230
                                _ecode = DBUS_GERROR_TIMEOUT;
 
1231
                        } else if (strcmp (_tmp15_, "NoNetwork") == 0) {
 
1232
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
1233
                        } else if (strcmp (_tmp15_, "AddressInUse") == 0) {
 
1234
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
1235
                        } else if (strcmp (_tmp15_, "Disconnected") == 0) {
 
1236
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
1237
                        } else if (strcmp (_tmp15_, "InvalidArgs") == 0) {
 
1238
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
1239
                        } else if (strcmp (_tmp15_, "FileNotFound") == 0) {
 
1240
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
1241
                        } else if (strcmp (_tmp15_, "FileExists") == 0) {
 
1242
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
1243
                        } else if (strcmp (_tmp15_, "UnknownMethod") == 0) {
 
1244
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
1245
                        } else if (strcmp (_tmp15_, "TimedOut") == 0) {
 
1246
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
1247
                        } else if (strcmp (_tmp15_, "MatchRuleNotFound") == 0) {
 
1248
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
1249
                        } else if (strcmp (_tmp15_, "MatchRuleInvalid") == 0) {
 
1250
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
1251
                        } else if (strcmp (_tmp15_, "Spawn.ExecFailed") == 0) {
 
1252
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
1253
                        } else if (strcmp (_tmp15_, "Spawn.ForkFailed") == 0) {
 
1254
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
1255
                        } else if (strcmp (_tmp15_, "Spawn.ChildExited") == 0) {
 
1256
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
1257
                        } else if (strcmp (_tmp15_, "Spawn.ChildSignaled") == 0) {
 
1258
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
1259
                        } else if (strcmp (_tmp15_, "Spawn.Failed") == 0) {
 
1260
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
1261
                        } else if (strcmp (_tmp15_, "UnixProcessIdUnknown") == 0) {
 
1262
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
1263
                        } else if (strcmp (_tmp15_, "InvalidSignature") == 0) {
 
1264
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
1265
                        } else if (strcmp (_tmp15_, "InvalidFileContent") == 0) {
 
1266
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
1267
                        } else if (strcmp (_tmp15_, "SELinuxSecurityContextUnknown") == 0) {
 
1268
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
1269
                        } else if (strcmp (_tmp15_, "RemoteException") == 0) {
 
1270
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
1271
                        }
 
1272
                }
 
1273
                g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);
 
1274
                dbus_error_free (&_dbus_error);
 
1275
                return NULL;
 
1276
        }
 
1277
        if (strcmp (dbus_message_get_signature (_reply), "a(oas)")) {
 
1278
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "a(oas)", dbus_message_get_signature (_reply));
 
1279
                dbus_message_unref (_reply);
 
1280
                return NULL;
 
1281
        }
 
1282
        dbus_message_iter_init (_reply, &_iter);
 
1283
        _result_length1 = 0;
 
1284
        _tmp16_ = g_new (AccountFavourites, 5);
 
1285
        _tmp16__length = 0;
 
1286
        _tmp16__size = 4;
 
1287
        _tmp16__length1 = 0;
 
1288
        dbus_message_iter_recurse (&_iter, &_tmp17_);
 
1289
        for (; dbus_message_iter_get_arg_type (&_tmp17_); _tmp16__length1++) {
 
1290
                AccountFavourites _tmp18_;
 
1291
                DBusMessageIter _tmp19_;
 
1292
                const char* _tmp20_;
 
1293
                char** _tmp21_;
 
1294
                int _tmp21__length;
 
1295
                int _tmp21__size;
 
1296
                int _tmp21__length1;
 
1297
                DBusMessageIter _tmp22_;
 
1298
                if (_tmp16__size == _tmp16__length) {
 
1299
                        _tmp16__size = 2 * _tmp16__size;
 
1300
                        _tmp16_ = g_renew (AccountFavourites, _tmp16_, _tmp16__size + 1);
 
1301
                }
 
1302
                dbus_message_iter_recurse (&_tmp17_, &_tmp19_);
 
1303
                dbus_message_iter_get_basic (&_tmp19_, &_tmp20_);
 
1304
                dbus_message_iter_next (&_tmp19_);
 
1305
                _tmp18_.account_path = g_strdup (_tmp20_);
 
1306
                _tmp21_ = g_new (char*, 5);
 
1307
                _tmp21__length = 0;
 
1308
                _tmp21__size = 4;
 
1309
                _tmp21__length1 = 0;
 
1310
                dbus_message_iter_recurse (&_tmp19_, &_tmp22_);
 
1311
                for (; dbus_message_iter_get_arg_type (&_tmp22_); _tmp21__length1++) {
 
1312
                        const char* _tmp23_;
 
1313
                        if (_tmp21__size == _tmp21__length) {
 
1314
                                _tmp21__size = 2 * _tmp21__size;
 
1315
                                _tmp21_ = g_renew (char*, _tmp21_, _tmp21__size + 1);
 
1316
                        }
 
1317
                        dbus_message_iter_get_basic (&_tmp22_, &_tmp23_);
 
1318
                        dbus_message_iter_next (&_tmp22_);
 
1319
                        _tmp21_[_tmp21__length++] = g_strdup (_tmp23_);
 
1320
                }
 
1321
                _tmp18_.ids_length1 = _tmp21__length1;
 
1322
                _tmp21_[_tmp21__length] = NULL;
 
1323
                dbus_message_iter_next (&_tmp19_);
 
1324
                _tmp18_.ids = _tmp21_;
 
1325
                dbus_message_iter_next (&_tmp17_);
 
1326
                _tmp16_[_tmp16__length++] = _tmp18_;
 
1327
        }
 
1328
        _result_length1 = _tmp16__length1;
 
1329
        dbus_message_iter_next (&_iter);
 
1330
        _result = _tmp16_;
 
1331
        *result_length1 = _result_length1;
 
1332
        dbus_message_unref (_reply);
 
1333
        return _result;
 
1334
}
 
1335
 
 
1336
 
 
1337
static void logger_iface_dbus_proxy_add_favourite_contact_async (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1338
        DBusGConnection *_connection;
 
1339
        DBusMessage *_message;
 
1340
        DBusPendingCall *_pending;
 
1341
        DBusMessageIter _iter;
 
1342
        const char* _tmp24_;
 
1343
        const char* _tmp25_;
 
1344
        LoggerIfaceDBusProxyAddFavouriteContactData* _data_;
 
1345
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.Telepathy.Logger.DRAFT", "AddFavouriteContact");
 
1346
        dbus_message_iter_init_append (_message, &_iter);
 
1347
        _tmp24_ = account_path;
 
1348
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_OBJECT_PATH, &_tmp24_);
 
1349
        _tmp25_ = id;
 
1350
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp25_);
 
1351
        g_object_get (self, "connection", &_connection, NULL);
 
1352
        dbus_connection_send_with_reply (dbus_g_connection_get_connection (_connection), _message, &_pending, -1);
 
1353
        dbus_g_connection_unref (_connection);
 
1354
        dbus_message_unref (_message);
 
1355
        _data_ = g_slice_new0 (LoggerIfaceDBusProxyAddFavouriteContactData);
 
1356
        _data_->_callback_ = _callback_;
 
1357
        _data_->_user_data_ = _user_data_;
 
1358
        _data_->pending = _pending;
 
1359
        dbus_pending_call_set_notify (_pending, logger_iface_dbus_proxy_add_favourite_contact_ready, _data_, NULL);
 
1360
}
 
1361
 
 
1362
 
 
1363
static void logger_iface_dbus_proxy_add_favourite_contact_ready (DBusPendingCall* pending, void* user_data) {
 
1364
        LoggerIfaceDBusProxyAddFavouriteContactData* _data_;
 
1365
        GObject * _obj_;
 
1366
        GSimpleAsyncResult * _res_;
 
1367
        _data_ = user_data;
 
1368
        _obj_ = g_object_newv (G_TYPE_OBJECT, 0, NULL);
 
1369
        _res_ = g_simple_async_result_new (_obj_, _data_->_callback_, _data_->_user_data_, _data_);
 
1370
        g_simple_async_result_complete (_res_);
 
1371
        g_object_unref (_obj_);
 
1372
        g_object_unref (_res_);
 
1373
        g_slice_free (LoggerIfaceDBusProxyAddFavouriteContactData, _data_);
 
1374
        dbus_pending_call_unref (pending);
 
1375
}
 
1376
 
 
1377
 
 
1378
static void logger_iface_dbus_proxy_add_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error) {
 
1379
        LoggerIfaceDBusProxyAddFavouriteContactData* _data_;
 
1380
        DBusError _dbus_error;
 
1381
        DBusMessage *_reply;
 
1382
        DBusMessageIter _iter;
 
1383
        _data_ = g_simple_async_result_get_source_tag ((GSimpleAsyncResult *) _res_);
 
1384
        dbus_error_init (&_dbus_error);
 
1385
        _reply = dbus_pending_call_steal_reply (_data_->pending);
 
1386
        dbus_set_error_from_message (&_dbus_error, _reply);
 
1387
        if (dbus_error_is_set (&_dbus_error)) {
 
1388
                GQuark _edomain;
 
1389
                gint _ecode;
 
1390
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
1391
                        const char* _tmp26_;
 
1392
                        _edomain = DBUS_GERROR;
 
1393
                        _tmp26_ = _dbus_error.name + 27;
 
1394
                        if (strcmp (_tmp26_, "Failed") == 0) {
 
1395
                                _ecode = DBUS_GERROR_FAILED;
 
1396
                        } else if (strcmp (_tmp26_, "NoMemory") == 0) {
 
1397
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
1398
                        } else if (strcmp (_tmp26_, "ServiceUnknown") == 0) {
 
1399
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
1400
                        } else if (strcmp (_tmp26_, "NameHasNoOwner") == 0) {
 
1401
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
1402
                        } else if (strcmp (_tmp26_, "NoReply") == 0) {
 
1403
                                _ecode = DBUS_GERROR_NO_REPLY;
 
1404
                        } else if (strcmp (_tmp26_, "IOError") == 0) {
 
1405
                                _ecode = DBUS_GERROR_IO_ERROR;
 
1406
                        } else if (strcmp (_tmp26_, "BadAddress") == 0) {
 
1407
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
1408
                        } else if (strcmp (_tmp26_, "NotSupported") == 0) {
 
1409
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
1410
                        } else if (strcmp (_tmp26_, "LimitsExceeded") == 0) {
 
1411
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
1412
                        } else if (strcmp (_tmp26_, "AccessDenied") == 0) {
 
1413
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
1414
                        } else if (strcmp (_tmp26_, "AuthFailed") == 0) {
 
1415
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
1416
                        } else if (strcmp (_tmp26_, "NoServer") == 0) {
 
1417
                                _ecode = DBUS_GERROR_NO_SERVER;
 
1418
                        } else if (strcmp (_tmp26_, "Timeout") == 0) {
 
1419
                                _ecode = DBUS_GERROR_TIMEOUT;
 
1420
                        } else if (strcmp (_tmp26_, "NoNetwork") == 0) {
 
1421
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
1422
                        } else if (strcmp (_tmp26_, "AddressInUse") == 0) {
 
1423
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
1424
                        } else if (strcmp (_tmp26_, "Disconnected") == 0) {
 
1425
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
1426
                        } else if (strcmp (_tmp26_, "InvalidArgs") == 0) {
 
1427
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
1428
                        } else if (strcmp (_tmp26_, "FileNotFound") == 0) {
 
1429
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
1430
                        } else if (strcmp (_tmp26_, "FileExists") == 0) {
 
1431
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
1432
                        } else if (strcmp (_tmp26_, "UnknownMethod") == 0) {
 
1433
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
1434
                        } else if (strcmp (_tmp26_, "TimedOut") == 0) {
 
1435
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
1436
                        } else if (strcmp (_tmp26_, "MatchRuleNotFound") == 0) {
 
1437
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
1438
                        } else if (strcmp (_tmp26_, "MatchRuleInvalid") == 0) {
 
1439
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
1440
                        } else if (strcmp (_tmp26_, "Spawn.ExecFailed") == 0) {
 
1441
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
1442
                        } else if (strcmp (_tmp26_, "Spawn.ForkFailed") == 0) {
 
1443
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
1444
                        } else if (strcmp (_tmp26_, "Spawn.ChildExited") == 0) {
 
1445
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
1446
                        } else if (strcmp (_tmp26_, "Spawn.ChildSignaled") == 0) {
 
1447
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
1448
                        } else if (strcmp (_tmp26_, "Spawn.Failed") == 0) {
 
1449
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
1450
                        } else if (strcmp (_tmp26_, "UnixProcessIdUnknown") == 0) {
 
1451
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
1452
                        } else if (strcmp (_tmp26_, "InvalidSignature") == 0) {
 
1453
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
1454
                        } else if (strcmp (_tmp26_, "InvalidFileContent") == 0) {
 
1455
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
1456
                        } else if (strcmp (_tmp26_, "SELinuxSecurityContextUnknown") == 0) {
 
1457
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
1458
                        } else if (strcmp (_tmp26_, "RemoteException") == 0) {
 
1459
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
1460
                        }
 
1461
                }
 
1462
                g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);
 
1463
                dbus_error_free (&_dbus_error);
 
1464
                return;
 
1465
        }
 
1466
        if (strcmp (dbus_message_get_signature (_reply), "")) {
 
1467
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "", dbus_message_get_signature (_reply));
 
1468
                dbus_message_unref (_reply);
 
1469
                return;
 
1470
        }
 
1471
        dbus_message_iter_init (_reply, &_iter);
 
1472
        dbus_message_unref (_reply);
 
1473
}
 
1474
 
 
1475
 
 
1476
static void logger_iface_dbus_proxy_remove_favourite_contact_async (LoggerIface* self, const char* account_path, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1477
        DBusGConnection *_connection;
 
1478
        DBusMessage *_message;
 
1479
        DBusPendingCall *_pending;
 
1480
        DBusMessageIter _iter;
 
1481
        const char* _tmp29_;
 
1482
        const char* _tmp30_;
 
1483
        LoggerIfaceDBusProxyRemoveFavouriteContactData* _data_;
 
1484
        _message = dbus_message_new_method_call (dbus_g_proxy_get_bus_name ((DBusGProxy*) self), dbus_g_proxy_get_path ((DBusGProxy*) self), "org.freedesktop.Telepathy.Logger.DRAFT", "RemoveFavouriteContact");
 
1485
        dbus_message_iter_init_append (_message, &_iter);
 
1486
        _tmp29_ = account_path;
 
1487
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_OBJECT_PATH, &_tmp29_);
 
1488
        _tmp30_ = id;
 
1489
        dbus_message_iter_append_basic (&_iter, DBUS_TYPE_STRING, &_tmp30_);
 
1490
        g_object_get (self, "connection", &_connection, NULL);
 
1491
        dbus_connection_send_with_reply (dbus_g_connection_get_connection (_connection), _message, &_pending, -1);
 
1492
        dbus_g_connection_unref (_connection);
 
1493
        dbus_message_unref (_message);
 
1494
        _data_ = g_slice_new0 (LoggerIfaceDBusProxyRemoveFavouriteContactData);
 
1495
        _data_->_callback_ = _callback_;
 
1496
        _data_->_user_data_ = _user_data_;
 
1497
        _data_->pending = _pending;
 
1498
        dbus_pending_call_set_notify (_pending, logger_iface_dbus_proxy_remove_favourite_contact_ready, _data_, NULL);
 
1499
}
 
1500
 
 
1501
 
 
1502
static void logger_iface_dbus_proxy_remove_favourite_contact_ready (DBusPendingCall* pending, void* user_data) {
 
1503
        LoggerIfaceDBusProxyRemoveFavouriteContactData* _data_;
 
1504
        GObject * _obj_;
 
1505
        GSimpleAsyncResult * _res_;
 
1506
        _data_ = user_data;
 
1507
        _obj_ = g_object_newv (G_TYPE_OBJECT, 0, NULL);
 
1508
        _res_ = g_simple_async_result_new (_obj_, _data_->_callback_, _data_->_user_data_, _data_);
 
1509
        g_simple_async_result_complete (_res_);
 
1510
        g_object_unref (_obj_);
 
1511
        g_object_unref (_res_);
 
1512
        g_slice_free (LoggerIfaceDBusProxyRemoveFavouriteContactData, _data_);
 
1513
        dbus_pending_call_unref (pending);
 
1514
}
 
1515
 
 
1516
 
 
1517
static void logger_iface_dbus_proxy_remove_favourite_contact_finish (LoggerIface* self, GAsyncResult* _res_, GError** error) {
 
1518
        LoggerIfaceDBusProxyRemoveFavouriteContactData* _data_;
 
1519
        DBusError _dbus_error;
 
1520
        DBusMessage *_reply;
 
1521
        DBusMessageIter _iter;
 
1522
        _data_ = g_simple_async_result_get_source_tag ((GSimpleAsyncResult *) _res_);
 
1523
        dbus_error_init (&_dbus_error);
 
1524
        _reply = dbus_pending_call_steal_reply (_data_->pending);
 
1525
        dbus_set_error_from_message (&_dbus_error, _reply);
 
1526
        if (dbus_error_is_set (&_dbus_error)) {
 
1527
                GQuark _edomain;
 
1528
                gint _ecode;
 
1529
                if (strstr (_dbus_error.name, "org.freedesktop.DBus.Error") == _dbus_error.name) {
 
1530
                        const char* _tmp31_;
 
1531
                        _edomain = DBUS_GERROR;
 
1532
                        _tmp31_ = _dbus_error.name + 27;
 
1533
                        if (strcmp (_tmp31_, "Failed") == 0) {
 
1534
                                _ecode = DBUS_GERROR_FAILED;
 
1535
                        } else if (strcmp (_tmp31_, "NoMemory") == 0) {
 
1536
                                _ecode = DBUS_GERROR_NO_MEMORY;
 
1537
                        } else if (strcmp (_tmp31_, "ServiceUnknown") == 0) {
 
1538
                                _ecode = DBUS_GERROR_SERVICE_UNKNOWN;
 
1539
                        } else if (strcmp (_tmp31_, "NameHasNoOwner") == 0) {
 
1540
                                _ecode = DBUS_GERROR_NAME_HAS_NO_OWNER;
 
1541
                        } else if (strcmp (_tmp31_, "NoReply") == 0) {
 
1542
                                _ecode = DBUS_GERROR_NO_REPLY;
 
1543
                        } else if (strcmp (_tmp31_, "IOError") == 0) {
 
1544
                                _ecode = DBUS_GERROR_IO_ERROR;
 
1545
                        } else if (strcmp (_tmp31_, "BadAddress") == 0) {
 
1546
                                _ecode = DBUS_GERROR_BAD_ADDRESS;
 
1547
                        } else if (strcmp (_tmp31_, "NotSupported") == 0) {
 
1548
                                _ecode = DBUS_GERROR_NOT_SUPPORTED;
 
1549
                        } else if (strcmp (_tmp31_, "LimitsExceeded") == 0) {
 
1550
                                _ecode = DBUS_GERROR_LIMITS_EXCEEDED;
 
1551
                        } else if (strcmp (_tmp31_, "AccessDenied") == 0) {
 
1552
                                _ecode = DBUS_GERROR_ACCESS_DENIED;
 
1553
                        } else if (strcmp (_tmp31_, "AuthFailed") == 0) {
 
1554
                                _ecode = DBUS_GERROR_AUTH_FAILED;
 
1555
                        } else if (strcmp (_tmp31_, "NoServer") == 0) {
 
1556
                                _ecode = DBUS_GERROR_NO_SERVER;
 
1557
                        } else if (strcmp (_tmp31_, "Timeout") == 0) {
 
1558
                                _ecode = DBUS_GERROR_TIMEOUT;
 
1559
                        } else if (strcmp (_tmp31_, "NoNetwork") == 0) {
 
1560
                                _ecode = DBUS_GERROR_NO_NETWORK;
 
1561
                        } else if (strcmp (_tmp31_, "AddressInUse") == 0) {
 
1562
                                _ecode = DBUS_GERROR_ADDRESS_IN_USE;
 
1563
                        } else if (strcmp (_tmp31_, "Disconnected") == 0) {
 
1564
                                _ecode = DBUS_GERROR_DISCONNECTED;
 
1565
                        } else if (strcmp (_tmp31_, "InvalidArgs") == 0) {
 
1566
                                _ecode = DBUS_GERROR_INVALID_ARGS;
 
1567
                        } else if (strcmp (_tmp31_, "FileNotFound") == 0) {
 
1568
                                _ecode = DBUS_GERROR_FILE_NOT_FOUND;
 
1569
                        } else if (strcmp (_tmp31_, "FileExists") == 0) {
 
1570
                                _ecode = DBUS_GERROR_FILE_EXISTS;
 
1571
                        } else if (strcmp (_tmp31_, "UnknownMethod") == 0) {
 
1572
                                _ecode = DBUS_GERROR_UNKNOWN_METHOD;
 
1573
                        } else if (strcmp (_tmp31_, "TimedOut") == 0) {
 
1574
                                _ecode = DBUS_GERROR_TIMED_OUT;
 
1575
                        } else if (strcmp (_tmp31_, "MatchRuleNotFound") == 0) {
 
1576
                                _ecode = DBUS_GERROR_MATCH_RULE_NOT_FOUND;
 
1577
                        } else if (strcmp (_tmp31_, "MatchRuleInvalid") == 0) {
 
1578
                                _ecode = DBUS_GERROR_MATCH_RULE_INVALID;
 
1579
                        } else if (strcmp (_tmp31_, "Spawn.ExecFailed") == 0) {
 
1580
                                _ecode = DBUS_GERROR_SPAWN_EXEC_FAILED;
 
1581
                        } else if (strcmp (_tmp31_, "Spawn.ForkFailed") == 0) {
 
1582
                                _ecode = DBUS_GERROR_SPAWN_FORK_FAILED;
 
1583
                        } else if (strcmp (_tmp31_, "Spawn.ChildExited") == 0) {
 
1584
                                _ecode = DBUS_GERROR_SPAWN_CHILD_EXITED;
 
1585
                        } else if (strcmp (_tmp31_, "Spawn.ChildSignaled") == 0) {
 
1586
                                _ecode = DBUS_GERROR_SPAWN_CHILD_SIGNALED;
 
1587
                        } else if (strcmp (_tmp31_, "Spawn.Failed") == 0) {
 
1588
                                _ecode = DBUS_GERROR_SPAWN_FAILED;
 
1589
                        } else if (strcmp (_tmp31_, "UnixProcessIdUnknown") == 0) {
 
1590
                                _ecode = DBUS_GERROR_UNIX_PROCESS_ID_UNKNOWN;
 
1591
                        } else if (strcmp (_tmp31_, "InvalidSignature") == 0) {
 
1592
                                _ecode = DBUS_GERROR_INVALID_SIGNATURE;
 
1593
                        } else if (strcmp (_tmp31_, "InvalidFileContent") == 0) {
 
1594
                                _ecode = DBUS_GERROR_INVALID_FILE_CONTENT;
 
1595
                        } else if (strcmp (_tmp31_, "SELinuxSecurityContextUnknown") == 0) {
 
1596
                                _ecode = DBUS_GERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN;
 
1597
                        } else if (strcmp (_tmp31_, "RemoteException") == 0) {
 
1598
                                _ecode = DBUS_GERROR_REMOTE_EXCEPTION;
 
1599
                        }
 
1600
                }
 
1601
                g_set_error (error, _edomain, _ecode, "%s", _dbus_error.message);
 
1602
                dbus_error_free (&_dbus_error);
 
1603
                return;
 
1604
        }
 
1605
        if (strcmp (dbus_message_get_signature (_reply), "")) {
 
1606
                g_set_error (error, DBUS_GERROR, DBUS_GERROR_INVALID_SIGNATURE, "Invalid signature, expected \"%s\", got \"%s\"", "", dbus_message_get_signature (_reply));
 
1607
                dbus_message_unref (_reply);
 
1608
                return;
 
1609
        }
 
1610
        dbus_message_iter_init (_reply, &_iter);
 
1611
        dbus_message_unref (_reply);
 
1612
}
 
1613
 
 
1614
 
 
1615
static void logger_iface_dbus_proxy_logger_iface__interface_init (LoggerIfaceIface* iface) {
 
1616
        iface->get_favourite_contacts = logger_iface_dbus_proxy_get_favourite_contacts_async;
 
1617
        iface->get_favourite_contacts_finish = logger_iface_dbus_proxy_get_favourite_contacts_finish;
 
1618
        iface->add_favourite_contact = logger_iface_dbus_proxy_add_favourite_contact_async;
 
1619
        iface->add_favourite_contact_finish = logger_iface_dbus_proxy_add_favourite_contact_finish;
 
1620
        iface->remove_favourite_contact = logger_iface_dbus_proxy_remove_favourite_contact_async;
 
1621
        iface->remove_favourite_contact_finish = logger_iface_dbus_proxy_remove_favourite_contact_finish;
 
1622
}
 
1623
 
 
1624
 
 
1625
static void logger_iface_dbus_proxy_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
1626
}
 
1627
 
 
1628
 
 
1629
static void logger_iface_dbus_proxy_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
1630
}
 
1631
 
 
1632
 
 
1633
static void _lambda0_ (Logger* self) {
 
1634
        LoggerIface* _tmp0_;
 
1635
        logger_logger = (_tmp0_ = NULL, _g_object_unref0 (logger_logger), _tmp0_);
 
1636
        g_signal_emit_by_name (self, "invalidated");
 
1637
}
 
1638
 
 
1639
 
 
1640
static void __lambda0__dbus_g_proxy_destroy (DBusGProxy* _sender, gpointer self) {
 
1641
        _lambda0_ (self);
 
1642
}
 
1643
 
 
1644
 
 
1645
static void _lambda1_ (const char* ap, char** a, int a_length1, char** r, int r_length1, Logger* self) {
 
1646
        g_return_if_fail (ap != NULL);
 
1647
        if (_vala_strcmp0 (ap, self->priv->account_path) != 0) {
 
1648
                return;
 
1649
        }
 
1650
        g_signal_emit_by_name (self, "favourite-contacts-changed", a, a_length1, r, r_length1);
 
1651
}
 
1652
 
 
1653
 
 
1654
static void __lambda1__logger_iface_favourite_contacts_changed (LoggerIface* _sender, const char* account_path, char** added, int added_length1, char** removed, int removed_length1, gpointer self) {
 
1655
        _lambda1_ (account_path, added, added_length1, removed, removed_length1, self);
 
1656
}
 
1657
 
 
1658
 
 
1659
Logger* logger_construct (GType object_type, const char* account_path, GError** error) {
 
1660
        Logger * self;
 
1661
        char* _tmp1_;
 
1662
        GError * _inner_error_ = NULL;
 
1663
        g_return_val_if_fail (account_path != NULL, NULL);
 
1664
        self = (Logger*) g_object_new (object_type, NULL);
 
1665
        if (logger_logger == NULL) {
 
1666
                DBusGConnection* dbus_conn;
 
1667
                LoggerIface* _tmp0_;
 
1668
                dbus_conn = dbus_g_bus_get (DBUS_BUS_SESSION, &_inner_error_);
 
1669
                if (_inner_error_ != NULL) {
 
1670
                        if (_inner_error_->domain == DBUS_GERROR) {
 
1671
                                g_propagate_error (error, _inner_error_);
 
1672
                                _g_object_unref0 (self);
 
1673
                                return NULL;
 
1674
                        } else {
 
1675
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
1676
                                g_clear_error (&_inner_error_);
 
1677
                                return NULL;
 
1678
                        }
 
1679
                }
 
1680
                logger_logger = (_tmp0_ = logger_iface_dbus_proxy_new (dbus_conn, "org.freedesktop.Telepathy.Logger", "/org/freedesktop/Telepathy/Logger"), _g_object_unref0 (logger_logger), _tmp0_);
 
1681
                g_signal_connect_object ((DBusGProxy*) logger_logger, "destroy", (GCallback) __lambda0__dbus_g_proxy_destroy, self, 0);
 
1682
                _dbus_g_connection_unref0 (dbus_conn);
 
1683
        }
 
1684
        self->priv->account_path = (_tmp1_ = g_strdup (account_path), _g_free0 (self->priv->account_path), _tmp1_);
 
1685
        g_signal_connect_object (logger_logger, "favourite-contacts-changed", (GCallback) __lambda1__logger_iface_favourite_contacts_changed, self, 0);
 
1686
        return self;
 
1687
}
 
1688
 
 
1689
 
 
1690
Logger* logger_new (const char* account_path, GError** error) {
 
1691
        return logger_construct (TYPE_LOGGER, account_path, error);
 
1692
}
 
1693
 
 
1694
 
 
1695
static void logger_get_favourite_contacts_data_free (gpointer _data) {
 
1696
        LoggerGetFavouriteContactsData* data;
 
1697
        data = _data;
 
1698
        data->result = (_vala_array_free (data->result, data->result_length1, (GDestroyNotify) g_free), NULL);
 
1699
        g_object_unref (data->self);
 
1700
        g_slice_free (LoggerGetFavouriteContactsData, data);
 
1701
}
 
1702
 
 
1703
 
 
1704
void logger_get_favourite_contacts (Logger* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1705
        LoggerGetFavouriteContactsData* _data_;
 
1706
        _data_ = g_slice_new0 (LoggerGetFavouriteContactsData);
 
1707
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, logger_get_favourite_contacts);
 
1708
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, logger_get_favourite_contacts_data_free);
 
1709
        _data_->self = g_object_ref (self);
 
1710
        logger_get_favourite_contacts_co (_data_);
 
1711
}
 
1712
 
 
1713
 
 
1714
char** logger_get_favourite_contacts_finish (Logger* self, GAsyncResult* _res_, int* result_length1, GError** error) {
 
1715
        char** result;
 
1716
        LoggerGetFavouriteContactsData* _data_;
 
1717
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
 
1718
                return NULL;
 
1719
        }
 
1720
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
1721
        result = _data_->result;
 
1722
        *result_length1 = _data_->result_length1;
 
1723
        _data_->result = NULL;
 
1724
        return result;
 
1725
}
 
1726
 
 
1727
 
 
1728
static void logger_get_favourite_contacts_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
1729
        LoggerGetFavouriteContactsData* data;
 
1730
        data = _user_data_;
 
1731
        data->_res_ = _res_;
 
1732
        logger_get_favourite_contacts_co (data);
 
1733
}
 
1734
 
 
1735
 
 
1736
static char** _vala_array_dup3 (char** self, int length) {
 
1737
        char** result;
 
1738
        int i;
 
1739
        result = g_new0 (char*, length + 1);
 
1740
        for (i = 0; i < length; i++) {
 
1741
                result[i] = g_strdup (self[i]);
 
1742
        }
 
1743
        return result;
 
1744
}
 
1745
 
 
1746
 
 
1747
static gboolean logger_get_favourite_contacts_co (LoggerGetFavouriteContactsData* data) {
 
1748
        switch (data->_state_) {
 
1749
                case 0:
 
1750
                goto _state_0;
 
1751
                default:
 
1752
                g_assert_not_reached ();
 
1753
                case 10:
 
1754
                goto _state_10;
 
1755
        }
 
1756
        _state_0:
 
1757
        if (logger_logger == NULL) {
 
1758
                data->_tmp0_ = NULL;
 
1759
                data->result = (data->_tmp1_ = (data->_tmp0_ = g_new0 (char*, 0 + 1), data->_tmp0_), data->result_length1 = 0, data->_tmp1_);
 
1760
                {
 
1761
                        if (data->_state_ == 0) {
 
1762
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
1763
                        } else {
 
1764
                                g_simple_async_result_complete (data->_async_result);
 
1765
                        }
 
1766
                        g_object_unref (data->_async_result);
 
1767
                        return FALSE;
 
1768
                }
 
1769
        }
 
1770
        data->_state_ = 10;
 
1771
        logger_iface_get_favourite_contacts (logger_logger, logger_get_favourite_contacts_ready, data);
 
1772
        return FALSE;
 
1773
        _state_10:
 
1774
        data->favs = (data->_tmp3_ = logger_iface_get_favourite_contacts_finish (logger_logger, data->_res_, &data->_tmp2_, &data->_inner_error_), data->favs_length1 = data->_tmp2_, data->_favs_size_ = data->favs_length1, data->_tmp3_);
 
1775
        if (data->_inner_error_ != NULL) {
 
1776
                if (data->_inner_error_->domain == DBUS_GERROR) {
 
1777
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
1778
                        g_error_free (data->_inner_error_);
 
1779
                        {
 
1780
                                if (data->_state_ == 0) {
 
1781
                                        g_simple_async_result_complete_in_idle (data->_async_result);
 
1782
                                } else {
 
1783
                                        g_simple_async_result_complete (data->_async_result);
 
1784
                                }
 
1785
                                g_object_unref (data->_async_result);
 
1786
                                return FALSE;
 
1787
                        }
 
1788
                } else {
 
1789
                        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);
 
1790
                        g_clear_error (&data->_inner_error_);
 
1791
                        return FALSE;
 
1792
                }
 
1793
        }
 
1794
        {
 
1795
                data->account_collection = data->favs;
 
1796
                data->account_collection_length1 = data->favs_length1;
 
1797
                for (data->account_it = 0; data->account_it < data->favs_length1; data->account_it = data->account_it + 1) {
 
1798
                        memset (&data->_tmp6_, 0, sizeof (AccountFavourites));
 
1799
                        data->account = (account_favourites_copy (&data->account_collection[data->account_it], &data->_tmp6_), data->_tmp6_);
 
1800
                        {
 
1801
                                if (_vala_strcmp0 (data->account.account_path, data->self->priv->account_path) == 0) {
 
1802
                                        data->result = (data->_tmp5_ = (data->_tmp4_ = data->account.ids, (data->_tmp4_ == NULL) ? ((gpointer) data->_tmp4_) : _vala_array_dup3 (data->_tmp4_, data->account.ids_length1)), data->result_length1 = data->account.ids_length1, data->_tmp5_);
 
1803
                                        account_favourites_destroy (&data->account);
 
1804
                                        data->favs = (_vala_AccountFavourites_array_free (data->favs, data->favs_length1), NULL);
 
1805
                                        {
 
1806
                                                if (data->_state_ == 0) {
 
1807
                                                        g_simple_async_result_complete_in_idle (data->_async_result);
 
1808
                                                } else {
 
1809
                                                        g_simple_async_result_complete (data->_async_result);
 
1810
                                                }
 
1811
                                                g_object_unref (data->_async_result);
 
1812
                                                return FALSE;
 
1813
                                        }
 
1814
                                }
 
1815
                                account_favourites_destroy (&data->account);
 
1816
                        }
 
1817
                }
 
1818
        }
 
1819
        data->_tmp7_ = NULL;
 
1820
        data->result = (data->_tmp8_ = (data->_tmp7_ = g_new0 (char*, 0 + 1), data->_tmp7_), data->result_length1 = 0, data->_tmp8_);
 
1821
        data->favs = (_vala_AccountFavourites_array_free (data->favs, data->favs_length1), NULL);
 
1822
        {
 
1823
                if (data->_state_ == 0) {
 
1824
                        g_simple_async_result_complete_in_idle (data->_async_result);
 
1825
                } else {
 
1826
                        g_simple_async_result_complete (data->_async_result);
 
1827
                }
 
1828
                g_object_unref (data->_async_result);
 
1829
                return FALSE;
 
1830
        }
 
1831
        data->favs = (_vala_AccountFavourites_array_free (data->favs, data->favs_length1), NULL);
 
1832
        {
 
1833
                if (data->_state_ == 0) {
 
1834
                        g_simple_async_result_complete_in_idle (data->_async_result);
 
1835
                } else {
 
1836
                        g_simple_async_result_complete (data->_async_result);
 
1837
                }
 
1838
                g_object_unref (data->_async_result);
 
1839
                return FALSE;
 
1840
        }
 
1841
}
 
1842
 
 
1843
 
 
1844
static void logger_add_favourite_contact_data_free (gpointer _data) {
 
1845
        LoggerAddFavouriteContactData* data;
 
1846
        data = _data;
 
1847
        _g_free0 (data->id);
 
1848
        g_object_unref (data->self);
 
1849
        g_slice_free (LoggerAddFavouriteContactData, data);
 
1850
}
 
1851
 
 
1852
 
 
1853
void logger_add_favourite_contact (Logger* self, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1854
        LoggerAddFavouriteContactData* _data_;
 
1855
        _data_ = g_slice_new0 (LoggerAddFavouriteContactData);
 
1856
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, logger_add_favourite_contact);
 
1857
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, logger_add_favourite_contact_data_free);
 
1858
        _data_->self = g_object_ref (self);
 
1859
        _data_->id = g_strdup (id);
 
1860
        logger_add_favourite_contact_co (_data_);
 
1861
}
 
1862
 
 
1863
 
 
1864
void logger_add_favourite_contact_finish (Logger* self, GAsyncResult* _res_, GError** error) {
 
1865
        LoggerAddFavouriteContactData* _data_;
 
1866
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
 
1867
                return;
 
1868
        }
 
1869
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
1870
}
 
1871
 
 
1872
 
 
1873
static void logger_add_favourite_contact_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
1874
        LoggerAddFavouriteContactData* data;
 
1875
        data = _user_data_;
 
1876
        data->_res_ = _res_;
 
1877
        logger_add_favourite_contact_co (data);
 
1878
}
 
1879
 
 
1880
 
 
1881
static gboolean logger_add_favourite_contact_co (LoggerAddFavouriteContactData* data) {
 
1882
        switch (data->_state_) {
 
1883
                case 0:
 
1884
                goto _state_0;
 
1885
                default:
 
1886
                g_assert_not_reached ();
 
1887
                case 11:
 
1888
                goto _state_11;
 
1889
        }
 
1890
        _state_0:
 
1891
        if (logger_logger == NULL) {
 
1892
                {
 
1893
                        if (data->_state_ == 0) {
 
1894
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
1895
                        } else {
 
1896
                                g_simple_async_result_complete (data->_async_result);
 
1897
                        }
 
1898
                        g_object_unref (data->_async_result);
 
1899
                        return FALSE;
 
1900
                }
 
1901
        }
 
1902
        data->_state_ = 11;
 
1903
        logger_iface_add_favourite_contact (logger_logger, data->_tmp0_ = g_strdup (data->self->priv->account_path), data->id, logger_add_favourite_contact_ready, data);
 
1904
        return FALSE;
 
1905
        _state_11:
 
1906
        logger_iface_add_favourite_contact_finish (logger_logger, data->_res_, &data->_inner_error_);
 
1907
        _g_free0 (data->_tmp0_);
 
1908
        if (data->_inner_error_ != NULL) {
 
1909
                if (data->_inner_error_->domain == DBUS_GERROR) {
 
1910
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
1911
                        g_error_free (data->_inner_error_);
 
1912
                        {
 
1913
                                if (data->_state_ == 0) {
 
1914
                                        g_simple_async_result_complete_in_idle (data->_async_result);
 
1915
                                } else {
 
1916
                                        g_simple_async_result_complete (data->_async_result);
 
1917
                                }
 
1918
                                g_object_unref (data->_async_result);
 
1919
                                return FALSE;
 
1920
                        }
 
1921
                } else {
 
1922
                        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);
 
1923
                        g_clear_error (&data->_inner_error_);
 
1924
                        return FALSE;
 
1925
                }
 
1926
        }
 
1927
        {
 
1928
                if (data->_state_ == 0) {
 
1929
                        g_simple_async_result_complete_in_idle (data->_async_result);
 
1930
                } else {
 
1931
                        g_simple_async_result_complete (data->_async_result);
 
1932
                }
 
1933
                g_object_unref (data->_async_result);
 
1934
                return FALSE;
 
1935
        }
 
1936
}
 
1937
 
 
1938
 
 
1939
static void logger_remove_favourite_contact_data_free (gpointer _data) {
 
1940
        LoggerRemoveFavouriteContactData* data;
 
1941
        data = _data;
 
1942
        _g_free0 (data->id);
 
1943
        g_object_unref (data->self);
 
1944
        g_slice_free (LoggerRemoveFavouriteContactData, data);
 
1945
}
 
1946
 
 
1947
 
 
1948
void logger_remove_favourite_contact (Logger* self, const char* id, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
1949
        LoggerRemoveFavouriteContactData* _data_;
 
1950
        _data_ = g_slice_new0 (LoggerRemoveFavouriteContactData);
 
1951
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, logger_remove_favourite_contact);
 
1952
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, logger_remove_favourite_contact_data_free);
 
1953
        _data_->self = g_object_ref (self);
 
1954
        _data_->id = g_strdup (id);
 
1955
        logger_remove_favourite_contact_co (_data_);
 
1956
}
 
1957
 
 
1958
 
 
1959
void logger_remove_favourite_contact_finish (Logger* self, GAsyncResult* _res_, GError** error) {
 
1960
        LoggerRemoveFavouriteContactData* _data_;
 
1961
        if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (_res_), error)) {
 
1962
                return;
 
1963
        }
 
1964
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
1965
}
 
1966
 
 
1967
 
 
1968
static void logger_remove_favourite_contact_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
1969
        LoggerRemoveFavouriteContactData* data;
 
1970
        data = _user_data_;
 
1971
        data->_res_ = _res_;
 
1972
        logger_remove_favourite_contact_co (data);
 
1973
}
 
1974
 
 
1975
 
 
1976
static gboolean logger_remove_favourite_contact_co (LoggerRemoveFavouriteContactData* data) {
 
1977
        switch (data->_state_) {
 
1978
                case 0:
 
1979
                goto _state_0;
 
1980
                default:
 
1981
                g_assert_not_reached ();
 
1982
                case 12:
 
1983
                goto _state_12;
 
1984
        }
 
1985
        _state_0:
 
1986
        if (logger_logger == NULL) {
 
1987
                {
 
1988
                        if (data->_state_ == 0) {
 
1989
                                g_simple_async_result_complete_in_idle (data->_async_result);
 
1990
                        } else {
 
1991
                                g_simple_async_result_complete (data->_async_result);
 
1992
                        }
 
1993
                        g_object_unref (data->_async_result);
 
1994
                        return FALSE;
 
1995
                }
 
1996
        }
 
1997
        data->_state_ = 12;
 
1998
        logger_iface_remove_favourite_contact (logger_logger, data->_tmp0_ = g_strdup (data->self->priv->account_path), data->id, logger_remove_favourite_contact_ready, data);
 
1999
        return FALSE;
 
2000
        _state_12:
 
2001
        logger_iface_remove_favourite_contact_finish (logger_logger, data->_res_, &data->_inner_error_);
 
2002
        _g_free0 (data->_tmp0_);
 
2003
        if (data->_inner_error_ != NULL) {
 
2004
                if (data->_inner_error_->domain == DBUS_GERROR) {
 
2005
                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
 
2006
                        g_error_free (data->_inner_error_);
 
2007
                        {
 
2008
                                if (data->_state_ == 0) {
 
2009
                                        g_simple_async_result_complete_in_idle (data->_async_result);
 
2010
                                } else {
 
2011
                                        g_simple_async_result_complete (data->_async_result);
 
2012
                                }
 
2013
                                g_object_unref (data->_async_result);
 
2014
                                return FALSE;
 
2015
                        }
 
2016
                } else {
 
2017
                        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);
 
2018
                        g_clear_error (&data->_inner_error_);
 
2019
                        return FALSE;
 
2020
                }
 
2021
        }
 
2022
        {
 
2023
                if (data->_state_ == 0) {
 
2024
                        g_simple_async_result_complete_in_idle (data->_async_result);
 
2025
                } else {
 
2026
                        g_simple_async_result_complete (data->_async_result);
 
2027
                }
 
2028
                g_object_unref (data->_async_result);
 
2029
                return FALSE;
 
2030
        }
 
2031
}
 
2032
 
 
2033
 
 
2034
static void logger_class_init (LoggerClass * klass) {
 
2035
        logger_parent_class = g_type_class_peek_parent (klass);
 
2036
        g_type_class_add_private (klass, sizeof (LoggerPrivate));
 
2037
        G_OBJECT_CLASS (klass)->finalize = logger_finalize;
 
2038
        g_signal_new ("invalidated", TYPE_LOGGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 
2039
        g_signal_new ("favourite_contacts_changed", TYPE_LOGGER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__BOXED_INT_BOXED_INT, G_TYPE_NONE, 4, G_TYPE_STRV, G_TYPE_INT, G_TYPE_STRV, G_TYPE_INT);
 
2040
}
 
2041
 
 
2042
 
 
2043
static void logger_instance_init (Logger * self) {
 
2044
        self->priv = LOGGER_GET_PRIVATE (self);
 
2045
}
 
2046
 
 
2047
 
 
2048
static void logger_finalize (GObject* obj) {
 
2049
        Logger * self;
 
2050
        self = LOGGER (obj);
 
2051
        _g_free0 (self->priv->account_path);
 
2052
        G_OBJECT_CLASS (logger_parent_class)->finalize (obj);
 
2053
}
 
2054
 
 
2055
 
 
2056
GType logger_get_type (void) {
 
2057
        static volatile gsize logger_type_id__volatile = 0;
 
2058
        if (g_once_init_enter (&logger_type_id__volatile)) {
 
2059
                static const GTypeInfo g_define_type_info = { sizeof (LoggerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) logger_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Logger), 0, (GInstanceInitFunc) logger_instance_init, NULL };
 
2060
                GType logger_type_id;
 
2061
                logger_type_id = g_type_register_static (G_TYPE_OBJECT, "Logger", &g_define_type_info, 0);
 
2062
                g_once_init_leave (&logger_type_id__volatile, logger_type_id);
 
2063
        }
 
2064
        return logger_type_id__volatile;
 
2065
}
 
2066
 
 
2067
 
 
2068
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
2069
        if ((array != NULL) && (destroy_func != NULL)) {
 
2070
                int i;
 
2071
                for (i = 0; i < array_length; i = i + 1) {
 
2072
                        if (((gpointer*) array)[i] != NULL) {
 
2073
                                destroy_func (((gpointer*) array)[i]);
 
2074
                        }
 
2075
                }
 
2076
        }
 
2077
}
 
2078
 
 
2079
 
 
2080
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
2081
        _vala_array_destroy (array, array_length, destroy_func);
 
2082
        g_free (array);
 
2083
}
 
2084
 
 
2085
 
 
2086
static int _vala_strcmp0 (const char * str1, const char * str2) {
 
2087
        if (str1 == NULL) {
 
2088
                return -(str1 != str2);
 
2089
        }
 
2090
        if (str2 == NULL) {
 
2091
                return str1 != str2;
 
2092
        }
 
2093
        return strcmp (str1, str2);
 
2094
}
 
2095
 
 
2096
 
 
2097
 
 
2098
static void g_cclosure_user_marshal_VOID__BOXED_BOXED_INT_BOXED_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
 
2099
        typedef void (*GMarshalFunc_VOID__BOXED_BOXED_INT_BOXED_INT) (gpointer data1, gpointer arg_1, gpointer arg_2, gint arg_3, gpointer arg_4, gint arg_5, gpointer data2);
 
2100
        register GMarshalFunc_VOID__BOXED_BOXED_INT_BOXED_INT callback;
 
2101
        register GCClosure * cc;
 
2102
        register gpointer data1, data2;
 
2103
        cc = (GCClosure *) closure;
 
2104
        g_return_if_fail (n_param_values == 6);
 
2105
        if (G_CCLOSURE_SWAP_DATA (closure)) {
 
2106
                data1 = closure->data;
 
2107
                data2 = param_values->data[0].v_pointer;
 
2108
        } else {
 
2109
                data1 = param_values->data[0].v_pointer;
 
2110
                data2 = closure->data;
 
2111
        }
 
2112
        callback = (GMarshalFunc_VOID__BOXED_BOXED_INT_BOXED_INT) (marshal_data ? marshal_data : cc->callback);
 
2113
        callback (data1, g_value_get_boxed (param_values + 1), g_value_get_boxed (param_values + 2), g_value_get_int (param_values + 3), g_value_get_boxed (param_values + 4), g_value_get_int (param_values + 5), data2);
 
2114
}
 
2115
 
 
2116
 
 
2117
static void g_cclosure_user_marshal_VOID__BOXED_INT_BOXED_INT (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
 
2118
        typedef void (*GMarshalFunc_VOID__BOXED_INT_BOXED_INT) (gpointer data1, gpointer arg_1, gint arg_2, gpointer arg_3, gint arg_4, gpointer data2);
 
2119
        register GMarshalFunc_VOID__BOXED_INT_BOXED_INT callback;
 
2120
        register GCClosure * cc;
 
2121
        register gpointer data1, data2;
 
2122
        cc = (GCClosure *) closure;
 
2123
        g_return_if_fail (n_param_values == 5);
 
2124
        if (G_CCLOSURE_SWAP_DATA (closure)) {
 
2125
                data1 = closure->data;
 
2126
                data2 = param_values->data[0].v_pointer;
 
2127
        } else {
 
2128
                data1 = param_values->data[0].v_pointer;
 
2129
                data2 = closure->data;
 
2130
        }
 
2131
        callback = (GMarshalFunc_VOID__BOXED_INT_BOXED_INT) (marshal_data ? marshal_data : cc->callback);
 
2132
        callback (data1, g_value_get_boxed (param_values + 1), g_value_get_int (param_values + 2), g_value_get_boxed (param_values + 3), g_value_get_int (param_values + 4), data2);
 
2133
}
 
2134
 
 
2135
 
 
2136