static void
upload_photo_wrote_body_data_cb (SoupMessage *msg,
SoupBuffer *chunk,
gpointer user_data)
{
PicasaWebService *self = user_data;
GthFileData *file_data;
char *details;
double current_file_fraction;
if (self->priv->post_photos->current == NULL)
return;
self->priv->post_photos->wrote_body_data_size += chunk->length;
if (self->priv->post_photos->wrote_body_data_size > msg->request_body->length)
return;
file_data = self->priv->post_photos->current->data;
/* Translators: %s is a filename */
details = g_strdup_printf (_("Uploading '%s'"), g_file_info_get_display_name (file_data->info));
current_file_fraction = (double) self->priv->post_photos->wrote_body_data_size / msg->request_body->length;
gth_task_progress (GTH_TASK (self),
NULL,
details,
FALSE,
(double) (self->priv->post_photos->uploaded_size + (g_file_info_get_size (file_data->info) * current_file_fraction)) / self->priv->post_photos->total_size);
g_free (details);
}
void
picasa_web_service_list_albums (PicasaWebService *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
OAuthAccount *account;
SoupMessage *msg;
char *url;
account = web_service_get_current_account (WEB_SERVICE (self));
g_return_if_fail (account != NULL);
gth_task_progress (GTH_TASK (self), _("Getting the album list"), NULL, TRUE, 0.0);
url = g_strconcat ("https://picasaweb.google.com/data/feed/api/user/", account->id, NULL);
msg = soup_message_new ("GET", url);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
picasa_web_service_list_albums,
list_albums_ready_cb,
self);
g_free (url);
}
void
facebook_service_upload_photos (FacebookService *self,
FacebookAlbum *album,
GList *file_list, /* GFile list */
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
gth_task_progress (GTH_TASK (self->priv->conn), _("Uploading the files to the server"), NULL, TRUE, 0.0);
post_photos_data_free (self->priv->post_photos);
self->priv->post_photos = g_new0 (PostPhotosData, 1);
self->priv->post_photos->album = _g_object_ref (album);
self->priv->post_photos->cancellable = _g_object_ref (cancellable);
self->priv->post_photos->callback = callback;
self->priv->post_photos->user_data = user_data;
self->priv->post_photos->total_size = 0;
self->priv->post_photos->n_files = 0;
_g_query_all_metadata_async (file_list,
FALSE,
TRUE,
"*",
self->priv->post_photos->cancellable,
upload_photos_info_ready_cb,
self);
}
void
picasa_web_service_post_photos (PicasaWebService *self,
PicasaWebAlbum *album,
GList *file_list, /* GFile list */
int max_width,
int max_height,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (album != NULL);
g_return_if_fail (self->priv->post_photos == NULL);
gth_task_progress (GTH_TASK (self),
_("Uploading the files to the server"),
"",
TRUE,
0.0);
self->priv->post_photos = g_new0 (PostPhotosData, 1);
self->priv->post_photos->album = g_object_ref (album);
self->priv->post_photos->max_width = max_width;
self->priv->post_photos->max_height = max_height;
self->priv->post_photos->cancellable = _g_object_ref (cancellable);
self->priv->post_photos->callback = callback;
self->priv->post_photos->user_data = user_data;
_g_query_all_metadata_async (file_list,
GTH_LIST_DEFAULT,
"*",
self->priv->post_photos->cancellable,
post_photos_info_ready_cb,
self);
}
void
facebook_service_get_user_info (FacebookService *self,
const char *fields,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
SoupMessage *msg;
gth_task_progress (GTH_TASK (self->priv->conn), _("Connecting to the server"), _("Getting account information"), TRUE, 0.0);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.users.getInfo");
g_hash_table_insert (data_set, "uids", (char *) facebook_connection_get_user_id (self->priv->conn));
g_hash_table_insert (data_set, "fields", (char *) fields);
facebook_connection_add_api_sig (self->priv->conn, data_set);
msg = soup_form_request_new_from_hash ("POST", FACEBOOK_HTTPS_REST_SERVER, data_set);
facebook_connection_send_message (self->priv->conn,
msg,
cancellable,
callback,
user_data,
facebook_service_get_user_info,
get_user_info_ready_cb,
self);
g_hash_table_destroy (data_set);
}
void
facebook_service_get_albums (FacebookService *self,
const char *user_id,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
SoupMessage *msg;
g_return_if_fail (user_id != NULL);
gth_task_progress (GTH_TASK (self->priv->conn), _("Getting the album list"), NULL, TRUE, 0.0);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.photos.getAlbums");
g_hash_table_insert (data_set, "uid", (char *) user_id);
facebook_connection_add_api_sig (self->priv->conn, data_set);
msg = soup_form_request_new_from_hash ("GET", FACEBOOK_HTTPS_REST_SERVER, data_set);
facebook_connection_send_message (self->priv->conn,
msg,
cancellable,
callback,
user_data,
facebook_service_get_albums,
get_albums_ready_cb,
self);
g_hash_table_destroy (data_set);
}
static void
process_current_file (GthPixbufListTask *self)
{
GthFileData *file_data;
GList *singleton;
if (self->priv->current == NULL) {
gth_task_completed (GTH_TASK (self), NULL);
return;
}
_g_object_unref (self->priv->original_pixbuf);
self->priv->original_pixbuf = NULL;
_g_object_unref (self->priv->new_pixbuf);
self->priv->new_pixbuf = NULL;
gth_task_progress (GTH_TASK (self),
NULL,
NULL,
FALSE,
((double) self->priv->n_current + 1) / (self->priv->n_files + 1));
file_data = self->priv->current->data;
singleton = g_list_append (NULL, g_object_ref (file_data->file));
_g_query_all_metadata_async (singleton,
FALSE,
TRUE,
"*",
gth_task_get_cancellable (GTH_TASK (self)),
file_info_ready_cb,
self);
_g_object_list_unref (singleton);
}
static void
pixbuf_task_progress_cb (GthTask *task,
const char *description,
const char *details,
gboolean pulse,
double fraction,
gpointer user_data)
{
GthPixbufListTask *self = user_data;
double total_fraction;
double file_fraction;
total_fraction = ((double) self->priv->n_current + 1) / (self->priv->n_files + 1);
if (pulse)
file_fraction = 0.5;
else
file_fraction = fraction;
if (details == NULL) {
GthFileData *file_data;
file_data = self->priv->current->data;
details = g_file_info_get_display_name (file_data->info);
}
gth_task_progress (GTH_TASK (self),
description,
details,
FALSE,
total_fraction + (file_fraction / (self->priv->n_files + 1)));
}
void
web_service_ask_authorization (WebService *self)
{
gth_task_progress (GTH_TASK (self),
_("Connecting to the server"),
_("Asking authorization"),
TRUE,
0.0);
web_service_set_current_account (self, NULL);
WEB_SERVICE_GET_CLASS (self)->ask_authorization (self);
}
void
web_service_get_user_info (WebService *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
gth_task_progress (GTH_TASK (self),
_("Connecting to the server"),
_("Getting account information"),
TRUE,
0.0);
WEB_SERVICE_GET_CLASS (self)->get_user_info (self, cancellable, callback, user_data);
}
void
facebook_service_list_photos (FacebookService *self,
FacebookPhotoset *photoset,
const char *extras,
int per_page,
int page,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
char *s;
SoupMessage *msg;
g_return_if_fail (photoset != NULL);
gth_task_progress (GTH_TASK (self->priv->conn), _("Getting the photo list"), NULL, TRUE, 0.0);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.photosets.getPhotos");
g_hash_table_insert (data_set, "photoset_id", photoset->id);
if (extras != NULL)
g_hash_table_insert (data_set, "extras", (char *) extras);
if (per_page > 0) {
s = g_strdup_printf ("%d", per_page);
g_hash_table_insert (data_set, "per_page", s);
g_free (s);
}
if (page > 0) {
s = g_strdup_printf ("%d", page);
g_hash_table_insert (data_set, "page", s);
g_free (s);
}
facebook_connection_add_api_sig (self->priv->conn, data_set);
msg = soup_form_request_new_from_hash ("GET", "http://api.facebook.com/services/rest", data_set);
facebook_connection_send_message (self->priv->conn,
msg,
cancellable,
callback,
user_data,
facebook_service_list_photos,
list_photos_ready_cb,
self);
g_hash_table_destroy (data_set);
}
void
picasa_web_service_create_album (PicasaWebService *self,
PicasaWebAlbum *album,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
OAuthAccount *account;
DomDocument *doc;
DomElement *entry;
char *buffer;
gsize len;
char *url;
SoupMessage *msg;
account = web_service_get_current_account (WEB_SERVICE (self));
g_return_if_fail (account != NULL);
gth_task_progress (GTH_TASK (self), _("Creating the new album"), NULL, TRUE, 0.0);
doc = dom_document_new ();
entry = dom_domizable_create_element (DOM_DOMIZABLE (album), doc);
dom_element_append_child (DOM_ELEMENT (doc), entry);
buffer = dom_document_dump (doc, &len);
url = g_strconcat ("https://picasaweb.google.com/data/feed/api/user/", account->id, NULL);
msg = soup_message_new ("POST", url);
soup_message_set_request (msg, ATOM_ENTRY_MIME_TYPE, SOUP_MEMORY_TAKE, buffer, len);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
picasa_web_service_create_album,
create_album_ready_cb,
self);
g_free (url);
g_object_unref (doc);
}
void
facebook_service_create_album (FacebookService *self,
FacebookAlbum *album,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
const char *privacy;
SoupMessage *msg;
g_return_if_fail (album != NULL);
g_return_if_fail (album->name != NULL);
gth_task_progress (GTH_TASK (self->priv->conn), _("Creating the new album"), NULL, TRUE, 0.0);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.photos.createAlbum");
g_hash_table_insert (data_set, "name", album->name);
if (album->description != NULL)
g_hash_table_insert (data_set, "description", album->description);
if (album->location != NULL)
g_hash_table_insert (data_set, "location", album->location);
privacy = get_privacy_from_visibility (album->visibility);
if (privacy != NULL)
g_hash_table_insert (data_set, "privacy", (char *) privacy);
facebook_connection_add_api_sig (self->priv->conn, data_set);
msg = soup_form_request_new_from_hash ("POST", FACEBOOK_HTTPS_REST_SERVER, data_set);
facebook_connection_send_message (self->priv->conn,
msg,
cancellable,
callback,
user_data,
facebook_service_create_album,
create_album_ready_cb,
self);
g_hash_table_destroy (data_set);
}
static void
negative_init (GthAsyncTask *task,
gpointer user_data)
{
gth_task_progress (GTH_TASK (task), _("Applying changes"), NULL, TRUE, 0.0);
}
static void
upload_photo_file_buffer_ready_cb (void **buffer,
gsize count,
GError *error,
gpointer user_data)
{
FacebookService *self = user_data;
GthFileData *file_data;
SoupMultipart *multipart;
char *uri;
SoupBuffer *body;
SoupMessage *msg;
if (error != NULL) {
upload_photos_done (self, error);
return;
}
file_data = self->priv->post_photos->current->data;
multipart = soup_multipart_new ("multipart/form-data");
/* the metadata part */
{
GHashTable *data_set;
char *title;
char *description;
GList *keys;
GList *scan;
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "method", "facebook.photos.upload");
title = gth_file_data_get_attribute_as_string (file_data, "general::title");
description = gth_file_data_get_attribute_as_string (file_data, "general::description");
if (description != NULL)
g_hash_table_insert (data_set, "caption", description);
else if (title != NULL)
g_hash_table_insert (data_set, "caption", title);
if (self->priv->post_photos->album != NULL)
g_hash_table_insert (data_set, "aid", self->priv->post_photos->album->id);
facebook_connection_add_api_sig (self->priv->conn, data_set);
keys = g_hash_table_get_keys (data_set);
for (scan = keys; scan; scan = scan->next) {
char *key = scan->data;
soup_multipart_append_form_string (multipart, key, g_hash_table_lookup (data_set, key));
}
g_list_free (keys);
g_hash_table_unref (data_set);
}
/* the file part */
uri = g_file_get_uri (file_data->file);
body = soup_buffer_new (SOUP_MEMORY_TEMPORARY, *buffer, count);
soup_multipart_append_form_file (multipart,
NULL,
_g_uri_get_basename (uri),
gth_file_data_get_mime_type (file_data),
body);
soup_buffer_free (body);
g_free (uri);
/* send the file */
{
char *details;
/* Translators: %s is a filename */
details = g_strdup_printf (_("Uploading '%s'"), g_file_info_get_display_name (file_data->info));
gth_task_progress (GTH_TASK (self->priv->conn),
NULL, details,
FALSE,
(double) (self->priv->post_photos->uploaded_size + (g_file_info_get_size (file_data->info) / 2.0)) / self->priv->post_photos->total_size);
g_free (details);
}
msg = soup_form_request_new_from_multipart (FACEBOOK_HTTPS_REST_SERVER, multipart);
facebook_connection_send_message (self->priv->conn,
msg,
self->priv->post_photos->cancellable,
self->priv->post_photos->callback,
self->priv->post_photos->user_data,
facebook_service_upload_photos,
upload_photo_ready_cb,
self);
soup_multipart_free (multipart);
}
static void
sharpen_before (GthAsyncTask *task,
gpointer user_data)
{
gth_task_progress (GTH_TASK (task), _("Sharpening image"), NULL, TRUE, 0.0);
}