static void
photos_properties_dialog_location_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosPropertiesDialog *self = PHOTOS_PROPERTIES_DIALOG (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor = NULL; /* TODO: use g_autoptr */
{
g_autoptr (GError) error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
g_warning ("Unable to query latitude and longitude: %s", error->message);
goto out;
}
}
tracker_sparql_cursor_next_async (cursor,
self->cancellable,
photos_properties_dialog_location_cursor_next,
self);
out:
g_clear_object (&cursor);
}
static void
query_callback (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
NemoSearchEngineTracker *tracker;
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
tracker = NEMO_SEARCH_ENGINE_TRACKER (user_data);
connection = TRACKER_SPARQL_CONNECTION (object);
cursor = tracker_sparql_connection_query_finish (connection,
result,
&error);
if (error) {
tracker->details->query_pending = FALSE;
nemo_search_engine_error (NEMO_SEARCH_ENGINE (tracker), error->message);
g_error_free (error);
return;
}
if (!cursor) {
tracker->details->query_pending = FALSE;
nemo_search_engine_finished (NEMO_SEARCH_ENGINE (tracker));
return;
}
cursor_next (tracker, cursor);
}
static void find_channel_and_update (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
gchar **values;
GtkTreeModel *model;
GtkTreeIter iter;
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error);
if (error != NULL) {
g_warning ("Unable to update channel: %s", error->message);
g_error_free (error);
return;
}
model = user_data;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
if (retrive_row_by_id (model, tracker_sparql_cursor_get_string (cursor, 0, NULL), &iter) == TRUE) {
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL),
PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2),
PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL),
PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4),
PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5),
6, FALSE, -1);
}
}
}
static void
photos_fetch_ids_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GCancellable *cancellable;
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor; /* TODO: Use g_autoptr */
GError *error;
cancellable = g_task_get_cancellable (task);
error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
tracker_sparql_cursor_next_async (cursor,
cancellable,
photos_fetch_ids_job_cursor_next,
g_object_ref (task));
g_object_unref (cursor);
}
static void fill_model_with_channels (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
int i;
GtkWidget *dialog;
GtkListStore *list;
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object), res, &error);
if (error != NULL) {
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to fetch data about current feeds:\n%s", error->message);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "Is Tracker running?");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
return;
}
list = user_data;
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
gtk_list_store_insert_with_values (list, NULL, G_MAXINT,
PREDICATE_SUBJECT, tracker_sparql_cursor_get_string (cursor, 0, NULL),
PREDICATE_NAME, tracker_sparql_cursor_get_string (cursor, 1, NULL),
PREDICATE_DOWNLOAD, tracker_sparql_cursor_get_boolean (cursor, 2),
PREDICATE_DOWNPATH, tracker_sparql_cursor_get_string (cursor, 3, NULL),
PREDICATE_MAXSIZE, tracker_sparql_cursor_get_double (cursor, 4),
PREDICATE_EXPIRY, tracker_sparql_cursor_get_double (cursor, 5),
6, FALSE, -1);
}
}
static void
decorator_query_remaining_items_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
TrackerDecorator *decorator = user_data;
TrackerDecoratorPrivate *priv;
TrackerSparqlCursor *cursor;
GError *error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (object),
result, &error);
priv = decorator->priv;
priv->querying = FALSE;
if (error || !tracker_sparql_cursor_next (cursor, NULL, &error)) {
decorator_notify_task_error (decorator, error);
g_error_free (error);
return;
}
priv->n_remaining_items = g_queue_get_length (&priv->item_cache) +
tracker_sparql_cursor_get_integer (cursor, 0);
g_object_unref (cursor);
g_debug ("Found %ld items to extract", priv->n_remaining_items);
if (priv->n_remaining_items > 0)
decorator_cache_next_items (decorator);
else
decorator_finish (decorator);
}
static void
query_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
TrackerSparqlCursor *cursor;
GError *error = NULL;
MyData *md = user_data;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (object),
res,
&error);
g_print ("Async query took: %.6f\n", g_timer_elapsed (md->timer, NULL));
g_timer_start (md->timer);
if (!error) {
tracker_sparql_cursor_next_async (cursor,
md->cancellable,
cursor_cb,
md);
} else {
g_critical ("Could not run query: %s", error->message);
if (cursor) {
g_object_unref (cursor);
}
g_error_free (error);
g_main_loop_quit (md->loop);
}
}
static void
photos_create_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosCreateCollectionJob *self = PHOTOS_CREATE_COLLECTION_JOB (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
GVariant *variant;
GVariant *child;
gchar *key = NULL;
gchar *val = NULL;
error = NULL;
variant = tracker_sparql_connection_update_blank_finish (connection, res, &error);
if (error != NULL)
{
g_warning ("Unable to create collection: %s", error->message);
g_error_free (error);
goto out;
}
child = g_variant_get_child_value (variant, 0); /* variant is now aa{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now s{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now {ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0);
key = g_variant_dup_string (child, NULL);
g_variant_unref (child);
child = g_variant_get_child_value (variant, 1);
val = g_variant_dup_string (child, NULL);
g_variant_unref (child);
g_variant_unref (variant);
if (g_strcmp0 (key, "res") == 0)
self->created_urn = val;
out:
if (self->callback != NULL)
(*self->callback) (self->created_urn, self->user_data);
self->created_urn = NULL;
g_free (val);
g_free (key);
}
static void
photos_utils_update_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
const gchar *urn = (gchar *) user_data;
{
g_autoptr (GError) error = NULL;
tracker_sparql_connection_update_finish (connection, res, &error);
if (error != NULL)
g_warning ("Unable to update %s: %s", urn, error->message);
}
}
static void
verify_tracker_update (GObject *source,
GAsyncResult *res,
gpointer unused)
{
GError *error = NULL;
tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source), res, &error);
if (error != NULL) {
g_warning ("Unable to update Tracker: %s", error->message);
g_error_free (error);
}
}
static void
photos_create_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
GVariant *variant;
GVariant *child;
gchar *key = NULL;
gchar *val = NULL;
error = NULL;
variant = tracker_sparql_connection_update_blank_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
child = g_variant_get_child_value (variant, 0); /* variant is now aa{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now s{ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0); /* variant is now {ss} */
g_variant_unref (variant);
variant = child;
child = g_variant_get_child_value (variant, 0);
key = g_variant_dup_string (child, NULL);
g_variant_unref (child);
child = g_variant_get_child_value (variant, 1);
val = g_variant_dup_string (child, NULL);
g_variant_unref (child);
g_variant_unref (variant);
if (g_strcmp0 (key, "res") == 0)
g_task_return_pointer (task, g_strdup (val), g_free);
else
g_task_return_new_error (task, PHOTOS_ERROR, 0, "Failed to parse GVariant");
g_free (val);
g_free (key);
}
static void
set_new_read_status (GObject *source,
GAsyncResult *res,
ItemStatusUpdate *update)
{
gchar *query;
GError *error = NULL;
tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source), res, &error);
if (error != NULL) {
g_warning ("Unable to update status of item in Tracker: %s", error->message);
g_error_free (error);
}
else {
query = g_strdup_printf ("INSERT {<%s> nmo:isRead %s}", update->id, update->read ? "true" : "false");
tracker_sparql_connection_update_async (TRACKER_SPARQL_CONNECTION (source), query, 0, NULL,
(GAsyncReadyCallback) verify_tracker_update, NULL);
g_free (query);
}
g_free (update->id);
g_free (update);
}
static void
photos_delete_item_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
error = NULL;
tracker_sparql_connection_update_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
g_task_return_boolean (task, TRUE);
}
static void
on_fetch_channels (GObject *source,
GAsyncResult *res,
ReaderEngine *engine)
{
TrackerSparqlCursor *cursor;
GError *error = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source), res, &error);
if (error != NULL) {
g_warning ("Unable to fetch channels from Tracker: %s", error->message);
g_error_free (error);
}
else {
pass_channels (engine, cursor);
}
}
static void
decorator_commit_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
TrackerSparqlConnection *conn;
TrackerDecoratorPrivate *priv;
TrackerDecorator *decorator;
GError *error = NULL;
GPtrArray *errors;
guint i;
decorator = user_data;
priv = decorator->priv;
conn = TRACKER_SPARQL_CONNECTION (object);
errors = tracker_sparql_connection_update_array_finish (conn, result, &error);
if (error) {
g_warning ("There was an error pushing metadata: %s\n", error->message);
}
if (errors) {
for (i = 0; i < errors->len; i++) {
SparqlUpdate *update;
GError *child_error;
child_error = g_ptr_array_index (errors, i);
update = &g_array_index (priv->commit_buffer, SparqlUpdate, i);
if (!child_error)
continue;
decorator_blacklist_add (decorator, update->id);
item_warn (conn, update->id, update->sparql, child_error);
}
g_ptr_array_unref (errors);
}
g_clear_pointer (&priv->commit_buffer, (GDestroyNotify) g_array_unref);
if (!decorator_check_commit (decorator))
decorator_cache_next_items (decorator);
}
static void
photos_camera_cache_equipment_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
tracker_sparql_cursor_next_async (cursor, NULL, photos_camera_cache_cursor_next, g_object_ref (task));
g_object_unref (cursor);
}
static void
photos_offset_controller_reset_count_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosOffsetController *self = PHOTOS_OFFSET_CONTROLLER (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
g_error_free (error);
return;
}
tracker_sparql_cursor_next_async (cursor, NULL, photos_offset_controller_cursor_next, g_object_ref (self));
g_object_unref (cursor);
}
static void
photos_set_collection_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosSetCollectionJob *self;
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
self = PHOTOS_SET_COLLECTION_JOB (g_task_get_source_object (task));
error = NULL;
tracker_sparql_connection_update_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
photos_set_collection_job_job_collector (self, task);
}
static void
query_callback (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GtkSearchEngineTracker *tracker;
TrackerSparqlConnection *connection;
TrackerSparqlCursor *cursor;
GError *error = NULL;
gdk_threads_enter ();
tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
tracker->priv->query_pending = FALSE;
connection = TRACKER_SPARQL_CONNECTION (object);
cursor = tracker_sparql_connection_query_finish (connection,
result,
&error);
g_debug ("Query returned cursor:%p", cursor);
if (error)
{
_gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
g_error_free (error);
gdk_threads_leave ();
return;
}
if (!cursor)
{
_gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
gdk_threads_leave ();
return;
}
cursor_next (tracker, cursor);
gdk_threads_leave ();
}
static void
photos_update_mtime_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosUpdateMtimeJob *self = PHOTOS_UPDATE_MTIME_JOB (user_data);
PhotosUpdateMtimeJobPrivate *priv = self->priv;
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
error = NULL;
tracker_sparql_connection_update_finish (connection, res, &error);
if (error != NULL)
{
g_warning ("Unable to update mtime: %s", error->message);
g_error_free (error);
goto out;
}
out:
if (priv->callback != NULL)
(*priv->callback) (priv->user_data);
}
static void
photos_tracker_controller_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosTrackerController *self = PHOTOS_TRACKER_CONTROLLER (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
GError *error;
TrackerSparqlCursor *cursor;
error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
photos_tracker_controller_query_finished (self, error);
g_error_free (error);
return;
}
tracker_sparql_cursor_next_async (cursor,
self->priv->cancellable,
photos_tracker_controller_cursor_next,
g_object_ref (self));
g_object_unref (cursor);
}
static void
photos_import_dialog_fetch_collections_local_query_executed (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PhotosImportDialog *self;
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor = NULL; /* TODO: use g_autoptr */
{
g_autoptr (GError) error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Unable to fetch local collections: %s", error->message);
goto out;
}
}
self = PHOTOS_IMPORT_DIALOG (user_data);
if (cursor == NULL)
goto out;
tracker_sparql_cursor_next_async (cursor,
self->cancellable,
photos_import_dialog_fetch_collections_local_cursor_next,
self);
out:
g_clear_object (&cursor);
return;
}
static void
decorator_cache_items_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
TrackerDecorator *decorator = user_data;
TrackerDecoratorPrivate *priv;
TrackerSparqlConnection *conn;
TrackerSparqlCursor *cursor;
TrackerDecoratorInfo *info;
GError *error = NULL;
conn = TRACKER_SPARQL_CONNECTION (object);
cursor = tracker_sparql_connection_query_finish (conn, result, &error);
priv = decorator->priv;
priv->querying = FALSE;
if (error) {
decorator_notify_task_error (decorator, error);
g_error_free (error);
} else {
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
info = tracker_decorator_info_new (decorator, cursor);
g_queue_push_tail (&priv->item_cache, info);
}
}
if (!g_queue_is_empty (&priv->item_cache) && !priv->processing) {
decorator_start (decorator);
} else if (g_queue_is_empty (&priv->item_cache) && priv->processing) {
decorator_finish (decorator);
}
decorator_pair_tasks (decorator);
g_object_unref (cursor);
}
static void
photos_fetch_collections_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosFetchCollectionsJob *self = PHOTOS_FETCH_COLLECTIONS_JOB (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor;
GError *error;
error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
g_warning ("Unable to fetch collections: %s", error->message);
g_error_free (error);
photos_fetch_collections_job_emit_callback (self);
return;
}
tracker_sparql_cursor_next_async (cursor,
NULL,
photos_fetch_collections_job_cursor_next,
g_object_ref (self));
g_object_unref (cursor);
}
static void
on_query_finished (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
TrackerSparqlCursor *cursor = NULL;
GDir *dir = NULL;
GHashTable *table = NULL;
const gchar *name;
gchar *dirname = NULL;
GList *to_remove = NULL;
cursor = tracker_sparql_connection_query_finish (TRACKER_SPARQL_CONNECTION (source_object),
res,
&error);
if (error) {
goto on_error;
}
dirname = g_build_filename (g_get_user_cache_dir (),
"media-art",
NULL);
if (!g_file_test (dirname, G_FILE_TEST_EXISTS)) {
/* Ignore this and just quit the function */
goto on_error;
}
dir = g_dir_open (dirname, 0, &error);
if (error) {
goto on_error;
}
table = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) NULL);
while (tracker_sparql_cursor_next (cursor, NULL, NULL)) {
gchar *target = NULL, *album_path = NULL;
const gchar *album, *artist;
album = tracker_sparql_cursor_get_string (cursor, 0, NULL);
artist = tracker_sparql_cursor_get_value_type (cursor, 1) != TRACKER_SPARQL_VALUE_TYPE_UNBOUND ? tracker_sparql_cursor_get_string (cursor, 1, NULL) : NULL;
/* The get_path API does stripping itself */
media_art_get_path (artist,
album,
"album", NULL,
&target, NULL);
g_hash_table_replace (table, target, target);
/* Also add the file to which the symlinks are made */
media_art_get_path (NULL,
album,
"album", NULL,
&album_path, NULL);
g_hash_table_replace (table, album_path, album_path);
}
/* Perhaps we should have an internal list of media art files that we made,
* instead of going over all the media art (which could also have been made
* by other softwares) */
for (name = g_dir_read_name (dir); name != NULL; name = g_dir_read_name (dir)) {
gpointer value;
gchar *full;
full = g_build_filename (dirname, name, NULL);
value = g_hash_table_lookup (table, full);
if (!value) {
g_message ("Removing media-art file %s: no album exists that has "
"any songs for this media-art cache", name);
to_remove = g_list_prepend (to_remove, (gpointer) full);
} else {
g_free (full);
}
}
g_list_foreach (to_remove, (GFunc) g_unlink, NULL);
g_list_foreach (to_remove, (GFunc) g_free, NULL);
g_list_free (to_remove);
on_error:
g_free (dirname);
if (table) {
g_hash_table_unref (table);
}
if (cursor) {
g_object_unref (cursor);
}
if (dir) {
g_dir_close (dir);
}
if (error) {
g_critical ("Error running cleanup of media-art: %s",
error->message ? error->message : "No error given");
g_error_free (error);
}
}
