← Back to branch summary

~didrocks/ubuntuone-client/dont-suffer-zg-crash

« back to all changes in this revision

Viewing changes to libsyncdaemon/syncdaemon-folders-interface.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Moya
  • Date: 2010-06-23 23:08:15 UTC
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20100623230815-4m3ugh10u9x9xzw5
Tags: upstream-1.3.2
Import upstream version 1.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libsyncdaemon/syncdaemon-folders-interface.c
27
27
 
28
28
struct _SyncdaemonFoldersInterfacePrivate {
29
29
        GObject *proxy;
 
30
        GHashTable *folders;
30
31
};
31
32
 
32
33
static void
35
36
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (object);
36
37
 
37
38
        if (interface->priv != NULL) {
 
39
                if (interface->priv->folders != NULL)
 
40
                        g_hash_table_destroy (interface->priv->folders);
 
41
 
38
42
                g_free (interface->priv);
39
43
        }
40
44
 
50
54
}
51
55
 
52
56
static void
53
 
folder_created_cb (DBusGProxy *proxy, GHashTable *folder_info, gpointer user_data)
54
 
{
55
 
        SyncdaemonDaemon *daemon = NULL;
56
 
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
57
 
 
58
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
59
 
        if (daemon != NULL)
60
 
                g_signal_emit_by_name (daemon, "folder_created", folder_info);
61
 
}
62
 
 
63
 
static void
64
 
folder_deleted_cb (DBusGProxy *proxy, GHashTable *folder_info, gpointer user_data)
65
 
{
66
 
        SyncdaemonDaemon *daemon = NULL;
67
 
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
68
 
 
69
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
70
 
        if (daemon != NULL)
71
 
                g_signal_emit_by_name (daemon, "folder_deleted", folder_info);
72
 
}
73
 
 
74
 
static void
75
 
folder_subscribed_cb (DBusGProxy *proxy, GHashTable *folder_info, gpointer user_data)
76
 
{
77
 
        SyncdaemonDaemon *daemon = NULL;
78
 
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
79
 
 
80
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
81
 
        if (daemon != NULL)
82
 
                g_signal_emit_by_name (daemon, "folder_subscribed", folder_info);
83
 
}
84
 
 
85
 
static void
86
 
folder_unsubscribed_cb (DBusGProxy *proxy, GHashTable *folder_info, gpointer user_data)
87
 
{
88
 
        SyncdaemonDaemon *daemon = NULL;
89
 
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
90
 
 
91
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
92
 
        if (daemon != NULL)
93
 
                g_signal_emit_by_name (daemon, "folder_unsubscribed", folder_info);
94
 
}
95
 
 
96
 
static void
97
 
udf_error_cb (DBusGProxy *proxy, GHashTable *folder_info, gchar *error, gpointer user_data)
98
 
{
99
 
        SyncdaemonDaemon *daemon = NULL;
100
 
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
101
 
 
102
 
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
103
 
        if (daemon != NULL)
104
 
                g_signal_emit_by_name (daemon, "error", error, folder_info);
 
57
folder_created_cb (DBusGProxy *proxy, GHashTable *hash, gpointer user_data)
 
58
{
 
59
        SyncdaemonFolderInfo *folder_info;
 
60
        SyncdaemonDaemon *daemon = NULL;
 
61
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
62
 
 
63
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
64
 
 
65
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
66
 
 
67
        /* Update our cache of folders */
 
68
        if (interface->priv->folders != NULL) {
 
69
                g_hash_table_insert (interface->priv->folders,
 
70
                                     g_strdup (syncdaemon_folder_info_get_path (folder_info)),
 
71
                                     folder_info);
 
72
 
 
73
                if (daemon != NULL)
 
74
                        g_signal_emit_by_name (daemon, "folder_created", TRUE, folder_info);
 
75
        } else {
 
76
                if (daemon != NULL)
 
77
                        g_signal_emit_by_name (daemon, "folder_created", TRUE, folder_info);
 
78
                g_object_unref (G_OBJECT (folder_info));
 
79
        }
 
80
}
 
81
 
 
82
static void
 
83
folder_create_error_cb (DBusGProxy *proxy, GHashTable *hash, gchar *error, gpointer user_data)
 
84
{
 
85
        SyncdaemonDaemon *daemon = NULL;
 
86
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
87
 
 
88
        /* Notify listeners */
 
89
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
90
        if (daemon != NULL) {
 
91
                SyncdaemonFolderInfo *folder_info;
 
92
 
 
93
                folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
94
                g_signal_emit_by_name (daemon, "folder_created", FALSE, folder_info);
 
95
                g_object_unref (G_OBJECT (folder_info));
 
96
        }
 
97
}
 
98
 
 
99
static void
 
100
folder_deleted_cb (DBusGProxy *proxy, GHashTable *hash, gpointer user_data)
 
101
{
 
102
        SyncdaemonFolderInfo *folder_info;
 
103
        SyncdaemonDaemon *daemon = NULL;
 
104
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
105
 
 
106
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
107
 
 
108
        /* Notify listeners */
 
109
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
110
        if (daemon != NULL)
 
111
                g_signal_emit_by_name (daemon, "folder_deleted", TRUE, folder_info);
 
112
 
 
113
        /* Update our cache of folders */
 
114
        if (interface->priv->folders != NULL)
 
115
                g_hash_table_remove (interface->priv->folders,
 
116
                                     syncdaemon_folder_info_get_path (folder_info));
 
117
 
 
118
        g_object_unref (G_OBJECT (folder_info));
 
119
}
 
120
 
 
121
static void
 
122
folder_delete_error_cb (DBusGProxy *proxy, GHashTable *hash, gchar *error, gpointer user_data)
 
123
{
 
124
        SyncdaemonFolderInfo *folder_info;
 
125
        SyncdaemonDaemon *daemon = NULL;
 
126
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
127
 
 
128
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
129
 
 
130
        /* Notify listeners */
 
131
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
132
        if (daemon != NULL)
 
133
                g_signal_emit_by_name (daemon, "folder_deleted", FALSE, folder_info);
 
134
 
 
135
        g_object_unref (G_OBJECT (folder_info));
 
136
}
 
137
 
 
138
static void
 
139
folder_subscribed_cb (DBusGProxy *proxy, GHashTable *hash, gpointer user_data)
 
140
{
 
141
        SyncdaemonFolderInfo *folder_info;
 
142
        SyncdaemonDaemon *daemon = NULL;
 
143
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
144
 
 
145
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
146
 
 
147
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
148
        if (daemon != NULL)
 
149
                g_signal_emit_by_name (daemon, "folder_subscribed", TRUE, folder_info);
 
150
 
 
151
        if (interface->priv->folders != NULL) {
 
152
                g_hash_table_insert (interface->priv->folders,
 
153
                                     g_strdup (syncdaemon_folder_info_get_path (folder_info)),
 
154
                                     folder_info);
 
155
        } else
 
156
                g_object_unref (G_OBJECT (folder_info));
 
157
}
 
158
 
 
159
static void
 
160
folder_subscribe_error_cb (DBusGProxy *proxy, GHashTable *hash, gchar *error, gpointer user_data)
 
161
{
 
162
        SyncdaemonFolderInfo *folder_info;
 
163
        SyncdaemonDaemon *daemon = NULL;
 
164
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
165
 
 
166
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
167
 
 
168
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
169
        if (daemon != NULL)
 
170
                g_signal_emit_by_name (daemon, "folder_subscribed", FALSE, folder_info);
 
171
 
 
172
        g_object_unref (G_OBJECT (folder_info));
 
173
}
 
174
 
 
175
static void
 
176
folder_unsubscribed_cb (DBusGProxy *proxy, GHashTable *hash, gpointer user_data)
 
177
{
 
178
        SyncdaemonFolderInfo *folder_info;
 
179
        SyncdaemonDaemon *daemon = NULL;
 
180
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
181
 
 
182
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
183
 
 
184
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
185
        if (daemon != NULL)
 
186
                g_signal_emit_by_name (daemon, "folder_unsubscribed", TRUE, folder_info);
 
187
 
 
188
        if (interface->priv->folders != NULL) {
 
189
                g_hash_table_insert (interface->priv->folders,
 
190
                                     g_strdup (syncdaemon_folder_info_get_path (folder_info)),
 
191
                                     folder_info);
 
192
        } else
 
193
                g_object_unref (G_OBJECT (folder_info));
 
194
}
 
195
 
 
196
static void
 
197
folder_unsubscribe_error_cb (DBusGProxy *proxy, GHashTable *hash, gchar *error, gpointer user_data)
 
198
{
 
199
        SyncdaemonFolderInfo *folder_info;
 
200
        SyncdaemonDaemon *daemon = NULL;
 
201
        SyncdaemonFoldersInterface *interface = SYNCDAEMON_FOLDERS_INTERFACE (user_data);
 
202
 
 
203
        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
204
 
 
205
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
206
        if (daemon != NULL)
 
207
                g_signal_emit_by_name (daemon, "folder_unsubscribed", FALSE, folder_info);
 
208
 
 
209
        g_object_unref (G_OBJECT (folder_info));
105
210
}
106
211
 
107
212
static void
155
260
                                         G_TYPE_STRING,
156
261
                                         G_TYPE_INVALID);
157
262
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderCreateError",
158
 
                                             G_CALLBACK (udf_error_cb), interface, NULL);
 
263
                                             G_CALLBACK (folder_create_error_cb), interface, NULL);
159
264
 
160
265
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderDeleteError",
161
266
                                         dbus_g_type_get_map ("GHashTable",
164
269
                                         G_TYPE_STRING,
165
270
                                         G_TYPE_INVALID);
166
271
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderDeleteError",
167
 
                                             G_CALLBACK (udf_error_cb), interface, NULL);
 
272
                                             G_CALLBACK (folder_delete_error_cb), interface, NULL);
168
273
 
169
274
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderSubscribeError",
170
275
                                         dbus_g_type_get_map ("GHashTable",
173
278
                                         G_TYPE_STRING,
174
279
                                         G_TYPE_INVALID);
175
280
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderSubscribeError",
176
 
                                             G_CALLBACK (udf_error_cb), interface, NULL);
 
281
                                             G_CALLBACK (folder_subscribe_error_cb), interface, NULL);
177
282
 
178
283
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderUnSubscribeError",
179
284
                                         dbus_g_type_get_map ("GHashTable",
181
286
                                                              G_TYPE_STRING),
182
287
                                         G_TYPE_STRING,
183
288
                                         G_TYPE_INVALID);
184
 
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderUnSubscribedError",
185
 
                                             G_CALLBACK (udf_error_cb), interface, NULL);
 
289
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "FolderUnSubscribeError",
 
290
                                             G_CALLBACK (folder_unsubscribe_error_cb), interface, NULL);
186
291
        }
187
292
}
188
293
 
229
334
 
230
335
/**
231
336
 * syncdaemon_folders_interface_get_folders:
 
337
 *
 
338
 * Return value: A GSList of #SyncdaemonFolderInfo containing all the folders being
 
339
 * synchronized by the user. When no longer needed, the list should be freed
 
340
 * by calling g_slist_free.
232
341
 */
233
342
GSList *
234
343
syncdaemon_folders_interface_get_folders (SyncdaemonFoldersInterface *interface)
235
344
{
236
 
        GSList *folders = NULL;
 
345
        GSList *returned_folders = NULL;
237
346
        GError *error = NULL;
238
347
 
239
348
        g_return_val_if_fail (SYNCDAEMON_IS_FOLDERS_INTERFACE (interface), NULL);
240
349
 
241
 
        if (!dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "get_folders", &error,
242
 
                                G_TYPE_INVALID,
243
 
                                dbus_g_type_get_collection ("GSList",
244
 
                                                            dbus_g_type_get_map
245
 
                                                            ("GHashTable",
246
 
                                                             G_TYPE_STRING,
247
 
                                                             G_TYPE_STRING)), &folders,
248
 
                                G_TYPE_INVALID)) {
249
 
                g_warning ("Error calling get_folders: %s", error->message);
250
 
                g_error_free (error);
 
350
        if (interface->priv->folders != NULL) {
 
351
                GHashTableIter iter;
 
352
                gchar *path;
 
353
                SyncdaemonFolderInfo *folder_info;
 
354
 
 
355
                /* If we already got the folders list, no need for an extra DBus call */
 
356
                g_hash_table_iter_init (&iter, interface->priv->folders);
 
357
                while (g_hash_table_iter_next (&iter, (gpointer *) &path, (gpointer *) &folder_info))
 
358
                        returned_folders = g_slist_append (returned_folders, folder_info);
 
359
        } else {
 
360
                GSList *list;
 
361
 
 
362
                if (dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "get_folders", &error,
 
363
                                       G_TYPE_INVALID,
 
364
                                       dbus_g_type_get_collection ("GSList",
 
365
                                                                   dbus_g_type_get_map
 
366
                                                                   ("GHashTable",
 
367
                                                                    G_TYPE_STRING,
 
368
                                                                    G_TYPE_STRING)), &list,
 
369
                                       G_TYPE_INVALID)) {
 
370
                        GSList *l;
 
371
 
 
372
                        /* Add the folders to our live-updating list */
 
373
                        interface->priv->folders = g_hash_table_new_full (g_str_hash, g_str_equal,
 
374
                                                                          g_free, g_object_unref);
 
375
                        for (l = list; l != NULL; l = l->next) {
 
376
                                SyncdaemonFolderInfo *folder_info;
 
377
 
 
378
                                folder_info = syncdaemon_folder_info_new_from_hash_table (l->data);
 
379
                                g_hash_table_insert (interface->priv->folders,
 
380
                                                     g_strdup (g_hash_table_lookup (l->data, "path")),
 
381
                                                     folder_info);
 
382
 
 
383
                                returned_folders = g_slist_append (returned_folders, folder_info);
 
384
                        }
 
385
 
 
386
                        /* Free memory */
 
387
                        g_slist_foreach (list, (GFunc) g_hash_table_destroy, NULL);
 
388
                        g_slist_free (list);
 
389
                } else {
 
390
                        g_warning ("Error calling get_folders: %s", error->message);
 
391
                        g_error_free (error);
 
392
                }
251
393
        }
252
394
 
253
 
        return folders;
 
395
        return returned_folders;
254
396
}
255
397
 
256
398
/**
257
399
 * syncdaemon_folders_interface_get_info:
 
400
 *
 
401
 * Return value: A #SyncdaemonFolderInfo object containing all the information
 
402
 * for the node. When no longer needed, it should be freed by calling
 
403
 * g_object_unref.
258
404
 */
259
 
GHashTable *
 
405
SyncdaemonFolderInfo *
260
406
syncdaemon_folders_interface_get_info (SyncdaemonFoldersInterface *interface, const gchar *path)
261
407
{
262
 
        GHashTable *info = NULL;
 
408
        SyncdaemonFolderInfo *folder_info = NULL;
263
409
        GError *error = NULL;
264
410
 
265
411
        g_return_val_if_fail (SYNCDAEMON_IS_FOLDERS_INTERFACE (interface), NULL);
266
412
        g_return_val_if_fail (path != NULL, NULL);
267
413
 
268
 
        if (!dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "get_info", &error,
269
 
                                G_TYPE_STRING, path,
270
 
                                G_TYPE_INVALID,
271
 
                                dbus_g_type_get_map ("GHashTable",
272
 
                                                        G_TYPE_STRING,
273
 
                                                        G_TYPE_STRING), &info,
274
 
                                G_TYPE_INVALID)) {
275
 
                g_warning ("Error calling get_info: %s", error->message);
276
 
                g_error_free (error);
277
 
        }
278
 
 
279
 
        return info;
 
414
        if (interface->priv->folders != NULL) {
 
415
                folder_info = g_hash_table_lookup (interface->priv->folders, path);
 
416
                if (folder_info != NULL)
 
417
                        folder_info = g_object_ref (G_OBJECT (folder_info));
 
418
        }
 
419
 
 
420
        if (!folder_info) {
 
421
                GHashTable *hash;
 
422
 
 
423
                if (dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "get_info", &error,
 
424
                                       G_TYPE_STRING, path,
 
425
                                       G_TYPE_INVALID,
 
426
                                       dbus_g_type_get_map ("GHashTable",
 
427
                                                            G_TYPE_STRING,
 
428
                                                            G_TYPE_STRING), &hash,
 
429
                                       G_TYPE_INVALID)) {
 
430
                        folder_info = syncdaemon_folder_info_new_from_hash_table (hash);
 
431
                } else {
 
432
                        g_warning ("Error calling get_info: %s", error->message);
 
433
                        g_error_free (error);
 
434
                }
 
435
        }
 
436
 
 
437
        return folder_info;
280
438
}
281
439
 
282
440
/**