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
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_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
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
photos_base_item_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (object);
PhotosBaseItemPrivate *priv = self->priv;
switch (prop_id)
{
case PROP_CURSOR:
priv->cursor = TRACKER_SPARQL_CURSOR (g_value_dup_object (value));
break;
case PROP_FAILED_THUMBNAILING:
priv->failed_thumbnailing = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
