← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ubuntuone-client/oneiric

« back to all changes in this revision

Viewing changes to libsyncdaemon/syncdaemon-status-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-status-interface.c
27
27
 
28
28
struct _SyncdaemonStatusInterfacePrivate {
29
29
        GObject *proxy;
 
30
        GHashTable *downloads;
 
31
        GHashTable *uploads;
30
32
};
31
33
 
32
34
static void
35
37
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (object);
36
38
 
37
39
        if (interface->priv != NULL) {
 
40
                if (interface->priv->downloads != NULL)
 
41
                        g_hash_table_destroy (interface->priv->downloads);
 
42
 
 
43
                if (interface->priv->uploads != NULL)
 
44
                        g_hash_table_destroy (interface->priv->uploads);
 
45
 
38
46
                g_free (interface->priv);
39
47
        }
40
48
 
55
63
        SyncdaemonDaemon *daemon;
56
64
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (user_data);
57
65
 
 
66
        if (interface->priv->downloads == NULL) {
 
67
                interface->priv->downloads = g_hash_table_new_full (g_str_hash, g_str_equal,
 
68
                                                                    g_free, g_object_unref);
 
69
        }
 
70
 
 
71
        g_hash_table_insert (interface->priv->downloads,
 
72
                             g_strdup (path),
 
73
                             syncdaemon_transfer_info_new (path));
 
74
 
58
75
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
59
76
        if (daemon != NULL)
60
77
                g_signal_emit_by_name (daemon, "download_started", path);
67
84
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (user_data);
68
85
 
69
86
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
70
 
        if (daemon != NULL)
71
 
                g_signal_emit_by_name (daemon, "download_finished", path, info);
 
87
        if (daemon != NULL) {
 
88
                SyncdaemonTransferInfo *tinfo;
 
89
 
 
90
                tinfo = g_hash_table_lookup (interface->priv->downloads, path);
 
91
                if (tinfo != NULL)
 
92
                        g_signal_emit_by_name (daemon, "download_finished", path, tinfo);
 
93
                else {
 
94
                        tinfo = syncdaemon_transfer_info_new_from_hash_table (info);
 
95
                        g_signal_emit_by_name (daemon, "download_finished", path, tinfo);
 
96
                        g_object_unref (G_OBJECT (tinfo));
 
97
                }
 
98
        }
 
99
 
 
100
        if (interface->priv->downloads != NULL)
 
101
                g_hash_table_remove (interface->priv->downloads, path);
72
102
}
73
103
 
74
104
static void
77
107
        SyncdaemonDaemon *daemon;
78
108
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (user_data);
79
109
 
 
110
        if (interface->priv->uploads == NULL) {
 
111
                interface->priv->uploads = g_hash_table_new_full (g_str_hash, g_str_equal,
 
112
                                                                  g_free, g_object_unref);
 
113
        }
 
114
 
 
115
        g_hash_table_insert (interface->priv->uploads,
 
116
                             g_strdup (path),
 
117
                             syncdaemon_transfer_info_new (path));
 
118
 
80
119
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
81
120
        if (daemon != NULL)
82
121
                g_signal_emit_by_name (daemon, "upload_started", path);
89
128
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (user_data);
90
129
 
91
130
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
92
 
        if (daemon != NULL)
93
 
                g_signal_emit_by_name (daemon, "upload_finished", path, info);
 
131
        if (daemon != NULL) {
 
132
                SyncdaemonTransferInfo *tinfo;
 
133
 
 
134
                tinfo = g_hash_table_lookup (interface->priv->uploads, path);
 
135
                if (tinfo != NULL)
 
136
                        g_signal_emit_by_name (daemon, "upload_finished", path, tinfo);
 
137
                else {
 
138
                        tinfo = syncdaemon_transfer_info_new_from_hash_table (info);
 
139
                        g_signal_emit_by_name (daemon, "upload_finished", path, tinfo);
 
140
                        g_object_unref (G_OBJECT (tinfo));
 
141
                }
 
142
        }
 
143
 
 
144
        if (interface->priv->downloads != NULL)
 
145
                g_hash_table_remove (interface->priv->uploads, path);
 
146
}
 
147
 
 
148
static void
 
149
download_file_progress_cb (DBusGProxy *proxy, gchar *path, GHashTable *info, gpointer user_data)
 
150
{
 
151
        SyncdaemonDaemon *daemon = NULL;
 
152
        SyncdaemonTransferInfo *tinfo;
 
153
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (user_data);
 
154
 
 
155
        tinfo = syncdaemon_transfer_info_new_from_hash_table (info);
 
156
        g_hash_table_insert (interface->priv->downloads,
 
157
                             g_strdup (path),
 
158
                             tinfo);
 
159
 
 
160
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
161
        if (daemon != NULL)
 
162
                g_signal_emit_by_name (daemon, "download_file_progress", path, tinfo);
 
163
}
 
164
 
 
165
static void
 
166
upload_file_progress_cb (DBusGProxy *proxy, gchar *path, GHashTable *info, gpointer user_data)
 
167
{
 
168
        SyncdaemonDaemon *daemon = NULL;
 
169
        SyncdaemonTransferInfo *tinfo;
 
170
        SyncdaemonStatusInterface *interface = SYNCDAEMON_STATUS_INTERFACE (user_data);
 
171
 
 
172
        tinfo = syncdaemon_transfer_info_new_from_hash_table (info);
 
173
        g_hash_table_insert (interface->priv->downloads,
 
174
                             g_strdup (path),
 
175
                             tinfo);
 
176
 
 
177
        g_object_get (G_OBJECT (interface), "daemon", &daemon, NULL);
 
178
        if (daemon != NULL)
 
179
                g_signal_emit_by_name (daemon, "upload_file_progress", path, tinfo);
94
180
}
95
181
 
96
182
static void
133
219
                                         G_TYPE_INVALID);
134
220
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "UploadFinished",
135
221
                                             G_CALLBACK (upload_finished_cb), interface, NULL);
 
222
 
 
223
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "DownloadFileProgress",
 
224
                                         G_TYPE_STRING,
 
225
                                         dbus_g_type_get_map ("GHashTable",
 
226
                                                              G_TYPE_STRING,
 
227
                                                              G_TYPE_STRING),
 
228
                                         G_TYPE_INVALID);
 
229
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "DownloadFileProgress",
 
230
                                                           G_CALLBACK (download_file_progress_cb), interface, NULL);
 
231
 
 
232
                dbus_g_proxy_add_signal (DBUS_G_PROXY (interface->priv->proxy), "UploadFileProgress",
 
233
                                         G_TYPE_STRING,
 
234
                                         dbus_g_type_get_map ("GHashTable",
 
235
                                                              G_TYPE_STRING,
 
236
                                                              G_TYPE_STRING),
 
237
                                         G_TYPE_INVALID);
 
238
                dbus_g_proxy_connect_signal (DBUS_G_PROXY (interface->priv->proxy), "UploadFileProgress",
 
239
                                                           G_CALLBACK (upload_file_progress_cb), interface, NULL);
136
240
        }
137
241
}
138
242
 
146
250
 
147
251
        return g_object_new (SYNCDAEMON_TYPE_STATUS_INTERFACE, "daemon", daemon, NULL);
148
252
}
 
253
 
 
254
/**
 
255
 * syncdaemon_status_interface_get_current_downloads:
 
256
 *
 
257
 * Return value: A GSList of #SyncdaemonTransferInfo objects, each of which contains
 
258
 * information about a file download in progress. The data in the list belongs to
 
259
 * the library, so when no longer needed, the list should be freed by just calling
 
260
 * g_slist_free.
 
261
 */
 
262
GSList *
 
263
syncdaemon_status_interface_get_current_downloads (SyncdaemonStatusInterface *interface)
 
264
{
 
265
        GHashTableIter iter;
 
266
        gchar *path;
 
267
        SyncdaemonTransferInfo *tinfo;
 
268
        GSList *downloads = NULL;
 
269
 
 
270
        g_return_val_if_fail (SYNCDAEMON_IS_STATUS_INTERFACE (interface), NULL);
 
271
 
 
272
        if (interface->priv->downloads == NULL) {
 
273
                GSList *list;
 
274
                GError *error = NULL;
 
275
 
 
276
                interface->priv->downloads = g_hash_table_new_full (g_str_hash, g_str_equal,
 
277
                                                                    g_free, g_object_unref);
 
278
 
 
279
                if (!dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "current_downloads", &error,
 
280
                                        G_TYPE_INVALID,
 
281
                                        dbus_g_type_get_collection ("GSList",
 
282
                                                            dbus_g_type_get_map
 
283
                                                            ("GHashTable",
 
284
                                                             G_TYPE_STRING,
 
285
                                                             G_TYPE_STRING)), &list,
 
286
                                        G_TYPE_INVALID)) {
 
287
                        g_warning ("Error calling current_downloads: %s", error->message);
 
288
                        g_error_free (error);
 
289
 
 
290
                        return NULL;
 
291
                }
 
292
 
 
293
                /* Now add all downloads to our cache */
 
294
                while (list != NULL) {
 
295
                        GHashTable *hash = (GHashTable *) list->data;
 
296
 
 
297
                        g_hash_table_insert (interface->priv->downloads,
 
298
                                             g_strdup (g_hash_table_lookup (hash, "path")),
 
299
                                             syncdaemon_transfer_info_new_from_hash_table (hash));
 
300
 
 
301
                        list = g_slist_remove (list, hash);
 
302
                        g_hash_table_destroy (hash);
 
303
                }
 
304
        }
 
305
 
 
306
        /* Create list to be returned to user */
 
307
        g_hash_table_iter_init (&iter, interface->priv->downloads);
 
308
        while (g_hash_table_iter_next (&iter, (gpointer *) &path, (gpointer *) &tinfo))
 
309
                downloads = g_slist_append (downloads, tinfo);
 
310
 
 
311
        return downloads;
 
312
}
 
313
 
 
314
/**
 
315
 * syncdaemon_status_interface_get_current_uploads:
 
316
 *
 
317
 * Return value: A GSList of #SyncdaemonTransferInfo objects, each of which contains
 
318
 * information about a file upload in progress. The data in the list belongs to
 
319
 * the library, so when no longer needed, the list should be freed by just calling
 
320
 * g_slist_free.
 
321
 */
 
322
GSList *
 
323
syncdaemon_status_interface_get_current_uploads (SyncdaemonStatusInterface *interface)
 
324
{
 
325
        GHashTableIter iter;
 
326
        gchar *path;
 
327
        SyncdaemonTransferInfo *tinfo;
 
328
        GSList *uploads = NULL;
 
329
 
 
330
        g_return_val_if_fail (SYNCDAEMON_IS_STATUS_INTERFACE (interface), NULL);
 
331
 
 
332
        if (interface->priv->uploads == NULL) {
 
333
                GSList *list;
 
334
                GError *error = NULL;
 
335
 
 
336
                interface->priv->uploads = g_hash_table_new_full (g_str_hash, g_str_equal,
 
337
                                                                  g_free, g_object_unref);
 
338
 
 
339
                if (!dbus_g_proxy_call (DBUS_G_PROXY (interface->priv->proxy), "current_uploads", &error,
 
340
                                        G_TYPE_INVALID,
 
341
                                        dbus_g_type_get_collection ("GSList",
 
342
                                                            dbus_g_type_get_map
 
343
                                                            ("GHashTable",
 
344
                                                             G_TYPE_STRING,
 
345
                                                             G_TYPE_STRING)), &list,
 
346
                                        G_TYPE_INVALID)) {
 
347
                        g_warning ("Error calling current_uploads: %s", error->message);
 
348
                        g_error_free (error);
 
349
 
 
350
                        return NULL;
 
351
                }
 
352
 
 
353
                /* Now add all uploads to our cache */
 
354
                while (list != NULL) {
 
355
                        GHashTable *hash = (GHashTable *) list->data;
 
356
 
 
357
                        g_hash_table_insert (interface->priv->uploads,
 
358
                                             g_strdup (g_hash_table_lookup (hash, "path")),
 
359
                                             syncdaemon_transfer_info_new_from_hash_table (hash));
 
360
 
 
361
                        list = g_slist_remove (list, hash);
 
362
                        g_hash_table_destroy (hash);
 
363
                }
 
364
        }
 
365
 
 
366
        /* Create list to be returned to user */
 
367
        g_hash_table_iter_init (&iter, interface->priv->uploads);
 
368
        while (g_hash_table_iter_next (&iter, (gpointer *) &path, (gpointer *) &tinfo))
 
369
                uploads = g_slist_append (uploads, tinfo);
 
370
 
 
371
        return uploads;
 
372
}