static void
_oauth_service_get_access_token (OAuthService *self,
const char *verifier,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
SoupMessage *msg;
data_set = g_hash_table_new (g_str_hash, g_str_equal);
if (verifier != NULL)
g_hash_table_insert (data_set, "oauth_verifier", (gpointer) verifier);
oauth_service_add_signature (self, "POST", self->priv->consumer->access_token_url, data_set);
msg = soup_form_request_new_from_hash ("POST", self->priv->consumer->access_token_url, data_set);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
_oauth_service_get_access_token,
_oauth_service_get_access_token_ready_cb,
self);
g_hash_table_destroy (data_set);
}
static void
_picasa_web_service_get_access_token (PicasaWebService *self,
const char *refresh_token,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GHashTable *data_set;
SoupMessage *msg;
_g_strset (&self->priv->access_token, NULL);
data_set = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (data_set, "refresh_token", (gpointer) refresh_token);
g_hash_table_insert (data_set, "client_id", GTHUMB_PICASA_WEB_CLIENT_ID);
g_hash_table_insert (data_set, "client_secret", GTHUMB_PICASA_WEB_CLIENT_SECRET);
g_hash_table_insert (data_set, "grant_type", "refresh_token");
msg = soup_form_request_new_from_hash ("POST", "https://accounts.google.com/o/oauth2/token", data_set);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
_picasa_web_service_get_access_token,
_picasa_web_service_get_access_token_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);
}
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);
}
/**
* push_c2dm_client_deliver_async:
* @client: A #PushC2dmClient.
* @identity: A #PushC2dmIdentity.
* @message: A #PushC2dmMessage.
* @cancellable: (allow-none): A #GCancellable, or %NULL.
* @callback: A callback to execute upon completion.
* @user_data: User data for @callback.
*
* Requests that @message is pushed to the device identified by @identity.
* Upon completion, @callback will be executed and is expected to call
* push_c2dm_client_deliver_finish() to retrieve the result.
*/
void
push_c2dm_client_deliver_async (PushC2dmClient *client,
PushC2dmIdentity *identity,
PushC2dmMessage *message,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
PushC2dmClientPrivate *priv;
GSimpleAsyncResult *simple;
const gchar *auth_header;
const gchar *registration_id;
SoupMessage *request;
GHashTable *params;
ENTRY;
g_return_if_fail(PUSH_IS_C2DM_CLIENT(client));
g_return_if_fail(PUSH_IS_C2DM_IDENTITY(identity));
g_return_if_fail(PUSH_IS_C2DM_MESSAGE(message));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
g_return_if_fail(callback);
priv = client->priv;
registration_id = push_c2dm_identity_get_registration_id(identity);
params = push_c2dm_message_build_params(message);
g_hash_table_insert(params,
g_strdup("registration_id"),
g_strdup(registration_id));
request = soup_form_request_new_from_hash(SOUP_METHOD_POST,
PUSH_C2DM_CLIENT_URL,
params);
auth_header = g_strdup_printf("GoogleLogin auth=%s", priv->auth_token);
soup_message_headers_append(request->request_headers,
"Authorization",
auth_header);
simple = g_simple_async_result_new(G_OBJECT(client), callback, user_data,
push_c2dm_client_deliver_async);
g_simple_async_result_set_check_cancellable(simple, cancellable);
g_object_set_data_full(G_OBJECT(simple), "registration-id",
g_strdup(registration_id), g_free);
soup_session_queue_message(SOUP_SESSION(client),
request,
push_c2dm_client_message_cb,
simple);
g_hash_table_unref(params);
EXIT;
}
static void
picasa_web_service_get_user_info (WebService *base,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
PicasaWebService *self = PICASA_WEB_SERVICE (base);
OAuthAccount *account;
GHashTable *data_set;
SoupMessage *msg;
account = web_service_get_current_account (WEB_SERVICE (self));
if (account != NULL) {
_g_strset (&self->priv->refresh_token, account->token_secret);
_g_strset (&self->priv->access_token, account->token);
}
data_set = g_hash_table_new (g_str_hash, g_str_equal);
if (self->priv->access_token != NULL) {
msg = soup_form_request_new_from_hash ("GET", "https://www.googleapis.com/oauth2/v2/userinfo", data_set);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
cancellable,
callback,
user_data,
picasa_web_service_get_user_info,
picasa_web_service_get_user_info_ready_cb,
self);
}
else {
/* Get the access token from the refresh token */
AccessTokenData *data;
data = g_new0 (AccessTokenData, 1);
data->service = self;
data->cancellable = _g_object_ref (cancellable);
data->callback = callback;
data->user_data = user_data;
_picasa_web_service_get_access_token (self,
self->priv->refresh_token,
cancellable,
access_token_ready_cb,
data);
}
g_hash_table_destroy (data_set);
}
static SoupMessage* prepare_message_to_put (OGDProvider *provider, gchar *query, GHashTable *data)
{
gchar *complete_query;
SoupMessage *msg;
complete_query = g_strdup_printf ("%s%s", provider->priv->access_url, query);
if (data != NULL)
msg = soup_form_request_new_from_hash ("POST", complete_query, data);
else
msg = soup_form_request_new ("POST", complete_query, NULL, NULL);
g_free (complete_query);
return msg;
}
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
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);
}
