static void
photos_single_item_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GDestroyNotify result_destroy = NULL;
GError *error;
gboolean success;
gpointer result = NULL;
error = NULL;
/* Note that tracker_sparql_cursor_next_finish can return FALSE even
* without an error.
*/
success = tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
if (success)
{
result = g_object_ref (cursor);
result_destroy = g_object_unref;
}
g_task_return_pointer (task, result, result_destroy);
out:
g_object_unref (task);
}
static void
photos_tracker_controller_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosTrackerController *self = PHOTOS_TRACKER_CONTROLLER (user_data);
PhotosTrackerControllerPrivate *priv = self->priv;
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
gboolean valid;
gint64 now;
valid = tracker_sparql_cursor_next_finish (cursor, res, NULL); /* TODO: use GError */
if (!valid)
{
tracker_sparql_cursor_close (cursor);
photos_tracker_controller_query_finished (self, NULL);
g_object_unref (self);
return;
}
now = g_get_monotonic_time ();
photos_debug (PHOTOS_DEBUG_TRACKER, "Query Cursor: %" G_GINT64_FORMAT, (now - priv->last_query_time) / 1000000);
photos_item_manager_add_item (PHOTOS_ITEM_MANAGER (priv->item_mngr), cursor);
tracker_sparql_cursor_next_async (cursor,
priv->cancellable,
photos_tracker_controller_cursor_next,
self);
}
static void
load_integer_value_next_cb (TrackerSparqlCursor *const cursor,
GAsyncResult *const result,
GTask *const task)
{
g_autoptr(GError) error = NULL;
gboolean const more = tracker_sparql_cursor_next_finish (
cursor,
result,
&error
);
if (!more) {
nul_warning ("no more rows to load");
g_task_return_int (task, -1);
return;
}
gint64 const integer = tracker_sparql_cursor_get_integer (cursor, 0);
g_task_return_int (task, integer);
}
static void
photos_fetch_collections_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosFetchCollectionsJob *self = PHOTOS_FETCH_COLLECTIONS_JOB (user_data);
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GError *error;
gboolean valid;
gchar *urn;
error = NULL;
valid = tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_warning ("Unable to fetch collections: %s", error->message);
g_error_free (error);
goto end;
}
if (!valid)
goto end;
urn = g_strdup (tracker_sparql_cursor_get_string (cursor, 0, NULL));
self->collections = g_list_prepend (self->collections, urn);
tracker_sparql_cursor_next_async (cursor,
NULL,
photos_fetch_collections_job_cursor_next,
self);
return;
end:
self->collections = g_list_reverse (self->collections);
photos_fetch_collections_job_emit_callback (self);
tracker_sparql_cursor_close (cursor);
g_object_unref (self);
}
static void
photos_import_dialog_fetch_collections_local_cursor_next (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PhotosImportDialog *self;
g_autoptr (PhotosBaseItem) collection = NULL;
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
gboolean success;
const gchar *identifier;
g_autofree gchar *identifier_time = NULL;
{
g_autoptr (GError) error = NULL;
/* Note that tracker_sparql_cursor_next_finish can return FALSE even
* without an error.
*/
success = tracker_sparql_cursor_next_finish (cursor, 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 (!success)
{
photos_import_dialog_initialize_index_and_popover (self);
goto out;
}
collection = photos_item_manager_create_item (PHOTOS_ITEM_MANAGER (self->item_mngr), G_TYPE_NONE, cursor, FALSE);
photos_import_dialog_add_collection (self, collection);
identifier = photos_base_item_get_identifier (collection);
identifier_time = g_strdup_printf ("%s%" G_GINT64_FORMAT, PHOTOS_QUERY_LOCAL_COLLECTIONS_IDENTIFIER, self->time);
if (g_strcmp0 (identifier, identifier_time) == 0)
{
const gchar *id;
id = photos_filterable_get_id (PHOTOS_FILTERABLE (collection));
photos_debug (PHOTOS_DEBUG_IMPORT, "Default collection already exists: %s", id);
g_set_object (&self->default_collection, collection);
}
tracker_sparql_cursor_next_async (cursor,
self->cancellable,
photos_import_dialog_fetch_collections_local_cursor_next,
self);
out:
return;
}
static void
cursor_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
TrackerSparqlCursor *cursor;
GError *error = NULL;
MyData *md = user_data;
gboolean more_results;
cursor = TRACKER_SPARQL_CURSOR (object);
more_results = tracker_sparql_cursor_next_finish (cursor,
res,
&error);
if (!error) {
static gint i = 0;
if (more_results) {
if (i++ < 5) {
if (i == 1) {
g_print ("Printing first 5 results:\n");
}
g_print (" %s\n", tracker_sparql_cursor_get_string (cursor, 0, NULL));
if (i == 5) {
g_print (" ...\n");
g_print (" Printing nothing for remaining results\n");
}
}
tracker_sparql_cursor_next_async (cursor,
md->cancellable,
cursor_cb,
md);
} else {
g_print ("\n");
g_print ("Async cursor next took: %.6f (for all %d results)\n",
g_timer_elapsed (md->timer, NULL), i);
g_object_unref (cursor);
g_main_loop_quit (md->loop);
}
} else {
g_critical ("Could not run cursor next: %s", error->message);
if (cursor) {
g_object_unref (cursor);
}
g_error_free (error);
g_main_loop_quit (md->loop);
}
}
static void
cursor_callback (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GtkSearchEngineTracker *tracker;
GError *error = NULL;
TrackerSparqlCursor *cursor;
GList *hits;
gboolean success;
gdk_threads_enter ();
tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
cursor = TRACKER_SPARQL_CURSOR (object);
success = tracker_sparql_cursor_next_finish (cursor, result, &error);
if (error)
{
_gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
g_error_free (error);
if (cursor)
g_object_unref (cursor);
gdk_threads_leave ();
return;
}
if (!success)
{
_gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
if (cursor)
g_object_unref (cursor);
gdk_threads_leave ();
return;
}
/* We iterate result by result, not n at a time. */
hits = g_list_append (NULL, (gchar*) tracker_sparql_cursor_get_string (cursor, 0, NULL));
_gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hits);
g_list_free (hits);
/* Get next */
cursor_next (tracker, cursor);
gdk_threads_leave ();
}
static void
photos_properties_dialog_location_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosPropertiesDialog *self;
g_autoptr (GeocodeLocation) location = NULL;
g_autoptr (GeocodeReverse) reverse = NULL;
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
gboolean success;
gdouble latitude;
gdouble longitude;
{
g_autoptr (GError) error = NULL;
/* Note that tracker_sparql_cursor_next_finish can return FALSE even
* without an error.
*/
success = tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Unable to read latitude and longitude: %s", error->message);
goto out;
}
}
self = PHOTOS_PROPERTIES_DIALOG (user_data);
/* Note that the following SPARQL query:
* SELECT slo:latitude (<(foo)>) slo:longitude (<(foo)>) WHERE {}
* ... will not return an empty cursor, but:
* (null), (null)
*/
if (!success)
{
g_warning ("Cursor is empty — possibly wrong SPARQL query");
goto out;
}
latitude = tracker_sparql_cursor_get_double (cursor, 0);
longitude = tracker_sparql_cursor_get_double (cursor, 1);
location = geocode_location_new (latitude, longitude, GEOCODE_LOCATION_ACCURACY_UNKNOWN);
reverse = geocode_reverse_new_for_location (location);
geocode_reverse_resolve_async (reverse,
self->cancellable,
photos_properties_dialog_location_reverse_resolve,
self);
out:
return;
}
static void
next_cb (GObject *const object,
GAsyncResult *const result,
GTask *const task)
{
g_autoptr(GError) error = NULL;
AsyncSparqlWork *const work = async_sparql_work_get (task);
TrackerSparqlCursor *const cursor = work->cursor;
gboolean const more = tracker_sparql_cursor_next_finish (
cursor,
result,
&error
);
if (error) {
nul_debug ("error: %s", error->message);
g_task_return_error (task, g_error_copy (error));
return;
}
if (!more) {
GVariant *const variant = g_variant_builder_end (work->builder);
nul_debug (
"end of data after %" G_GSIZE_FORMAT " rows",
g_variant_n_children (variant)
);
work->variant = g_variant_ref_sink (variant);
g_task_return_pointer (task, work, NULL);
return;
}
g_variant_builder_add_value (
work->builder,
work->func (cursor)
);
tracker_sparql_cursor_next_async (
cursor,
g_task_get_cancellable (task),
(GAsyncReadyCallback) next_cb,
task
);
}
static void
photos_camera_cache_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GTask *task = G_TASK (user_data);
PhotosCameraCache *self;
PhotosCameraCachePrivate *priv;
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GError *error;
const gchar *manufacturer;
const gchar *model;
gchar *camera;
gpointer key;
self = PHOTOS_CAMERA_CACHE (g_task_get_source_object (task));
priv = self->priv;
error = NULL;
tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
manufacturer = tracker_sparql_cursor_get_string (cursor, 0, NULL);
model = tracker_sparql_cursor_get_string (cursor, 1, NULL);
if (manufacturer == NULL && model == NULL)
camera = NULL;
else if (manufacturer == NULL || g_str_has_prefix (model, manufacturer))
camera = g_strdup (model);
else if (model == NULL)
camera = g_strdup (manufacturer);
else
camera = g_strconcat (manufacturer, " ", model, NULL);
key = g_task_get_task_data (task);
g_hash_table_insert (priv->cache, key, camera);
g_task_return_pointer (task, g_strdup (camera), g_free);
out:
tracker_sparql_cursor_close (cursor);
g_object_unref (task);
}
static void
photos_offset_controller_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosOffsetController *self = PHOTOS_OFFSET_CONTROLLER (user_data);
PhotosOffsetControllerPrivate *priv = self->priv;
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
gboolean valid;
valid = tracker_sparql_cursor_next_finish (cursor, res, NULL);
if (valid)
{
priv->count = (gint) tracker_sparql_cursor_get_integer (cursor, 0);
g_signal_emit (self, signals[COUNT_CHANGED], 0, priv->count);
}
tracker_sparql_cursor_close (cursor);
g_object_unref (self);
}
static void
photos_fetch_ids_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosFetchIdsJob *self;
GCancellable *cancellable;
g_autoptr (GTask) task = G_TASK (user_data);
TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object);
GError *error;
gboolean success;
self = PHOTOS_FETCH_IDS_JOB (g_task_get_source_object (task));
cancellable = g_task_get_cancellable (task);
error = NULL;
/* Note that tracker_sparql_cursor_next_finish can return FALSE even
* without an error.
*/
success = tracker_sparql_cursor_next_finish (cursor, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto end;
}
if (success)
{
const gchar *id;
id = tracker_sparql_cursor_get_string (cursor, PHOTOS_QUERY_COLUMNS_URN, NULL);
g_ptr_array_add (self->ids, g_strdup (id));
tracker_sparql_cursor_next_async (cursor,
cancellable,
photos_fetch_ids_job_cursor_next,
g_object_ref (task));
return;
}
g_ptr_array_add (self->ids, NULL);
g_task_return_pointer (task, self->ids->pdata, NULL);
end:
return;
}
static void
tracker_evt_preupdate_sources_item_cb (GObject *object,
GAsyncResult *result,
tracker_evt_update_t *evt)
{
const gchar *type, *datasource, *uri, *datasource_name;
gboolean source_available = FALSE;
GrlTrackerSource *source;
GError *error = NULL;
GRL_DEBUG ("%s: evt=%p", __FUNCTION__, evt);
if (!tracker_sparql_cursor_next_finish (evt->cursor, result, &error)) {
if (error != NULL) {
GRL_DEBUG ("\terror in parsing : %s", error->message);
g_error_free (error);
} else {
GRL_DEBUG ("\tend of parsing... start notifying sources");
}
g_clear_object (&evt->cursor);
/* Once all sources have been preupdated, start items
updates. */
tracker_evt_update_items (evt);
tracker_evt_update_orphans (evt);
return;
}
type = tracker_sparql_cursor_get_string (evt->cursor, 0, NULL);
datasource = tracker_sparql_cursor_get_string (evt->cursor, 1, NULL);
datasource_name = tracker_sparql_cursor_get_string (evt->cursor, 2, NULL);
uri = tracker_sparql_cursor_get_string (evt->cursor, 3, NULL);
if (tracker_sparql_cursor_is_bound (evt->cursor, 4))
source_available = tracker_sparql_cursor_get_boolean (evt->cursor, 4);
source = grl_tracker_source_find (datasource);
GRL_DEBUG ("\tdatasource=%s uri=%s available=%i source=%p",
datasource, uri, source_available, source);
if (source_available) {
if (source == NULL) {
gchar *source_name = grl_tracker_get_source_name (type, uri, datasource,
datasource_name);
/* Defer source creation until we have processed all sources */
if (source_name) {
tracker_evt_update_source_add (evt, datasource, source_name);
g_free (source_name);
}
} else {
GRL_DEBUG ("\tChanges on source %p / %s", source, datasource);
}
} else if (!source_available && source != NULL) {
tracker_evt_update_source_del (evt, GRL_TRACKER_SOURCE (source));
}
tracker_sparql_cursor_next_async (evt->cursor, NULL,
(GAsyncReadyCallback) tracker_evt_preupdate_sources_item_cb,
(gpointer) evt);
}
static void
tracker_evt_update_orphan_item_cb (GObject *object,
GAsyncResult *result,
tracker_evt_update_t *evt)
{
guint id;
const gchar *type, *datasource;
GrlTrackerSource *source = NULL;
GError *error = NULL;
GRL_DEBUG ("%s: evt=%p", __FUNCTION__, evt);
if (!tracker_sparql_cursor_next_finish (evt->cursor, result, &error)) {
if (error != NULL) {
GRL_DEBUG ("\terror in parsing : %s", error->message);
g_error_free (error);
} else {
GRL_DEBUG ("\tend of parsing...");
}
g_clear_object (&evt->cursor);
if (grl_tracker_per_device_source) {
/* Once all items have been processed, add new sources and we're
done. */
tracker_evt_postupdate_sources (evt);
} else {
tracker_evt_update_free (evt);
}
return;
}
type = tracker_sparql_cursor_get_string (evt->cursor, 0, NULL);
id = tracker_sparql_cursor_get_integer (evt->cursor, 1);
datasource = tracker_sparql_cursor_get_string (evt->cursor, 2, NULL);
GRL_DEBUG ("\tOrphan item: id=%u datasource=%s", id, datasource);
if (!grl_tracker_per_device_source)
source = grl_tracker_source_find ("");
if (!source && datasource)
source = grl_tracker_source_find (datasource);
if (source && GRL_IS_TRACKER_SOURCE (source)) {
GrlMedia *media;
GRL_DEBUG (" \tAdding to cache id=%u", id);
grl_tracker_source_cache_add_item (grl_tracker_item_cache, id, source);
if (grl_tracker_source_can_notify (source)) {
media = grl_tracker_build_grilo_media (type);
if (media) {
gchar *str_id = g_strdup_printf ("%i", id);
gint change_type =
GPOINTER_TO_INT (g_hash_table_lookup (evt->orphan_items,
GSIZE_TO_POINTER (id)));
grl_media_set_id (media, str_id);
g_free (str_id);
GRL_DEBUG ("\tNotify id=%u source=%s p=%p", id,
grl_source_get_name (GRL_SOURCE (source)),
source);
grl_source_notify_change (GRL_SOURCE (source),
media, change_type, FALSE);
g_object_unref (media);
}
}
}
tracker_sparql_cursor_next_async (evt->cursor, NULL,
(GAsyncReadyCallback) tracker_evt_update_orphan_item_cb,
(gpointer) evt);
}
