/** * tracker_miner_manager_get_running: * @manager: a #trackerMinerManager * * Returns a list of references for all active miners. Active miners * are miners which are running within a process. * * Returns: (transfer full) (element-type utf8) (nullable): a #GSList which * must be freed with g_slist_free() and all contained data with g_free(). * Otherwise %NULL is returned if there are no miners. * * Since: 0.8 **/ GSList * tracker_miner_manager_get_running (TrackerMinerManager *manager) { TrackerMinerManagerPrivate *priv; GSList *list = NULL; GError *error = NULL; GVariant *v; GVariantIter *iter; const gchar *str = NULL; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), NULL); priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager); if (!priv->connection) { return NULL; } v = g_dbus_connection_call_sync (priv->connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames", NULL, G_VARIANT_TYPE ("(as)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not get a list of names registered on the session bus, %s", error ? error->message : "no error given"); g_clear_error (&error); return NULL; } g_variant_get (v, "(as)", &iter); while (g_variant_iter_loop (iter, "&s", &str)) { if (!g_str_has_prefix (str, TRACKER_MINER_DBUS_NAME_PREFIX)) { continue; } /* Special case miner-fs which has * additional D-Bus interface. */ if (strcmp (str, "org.freedesktop.Tracker1.Miner.Files.Index") == 0) { continue; } list = g_slist_prepend (list, g_strdup (str)); } g_variant_iter_free (iter); g_variant_unref (v); list = g_slist_reverse (list); return list; }
/** * tracker_miner_manager_index_file: * @manager: a #TrackerMinerManager * @file: a URL valid in GIO of a file to give to the miner for processing * @error: (out callee-allocates) (transfer full) (allow-none): return location for errors * * Tells the filesystem miner to index the @file. * * On failure @error will be set. * * Returns: %TRUE on success, otherwise %FALSE. * * Since: 0.10 **/ gboolean tracker_miner_manager_index_file (TrackerMinerManager *manager, GFile *file, GError **error) { TrackerMinerManagerPrivate *priv; gchar *uri; GVariant *v; GError *new_error = NULL; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (G_IS_FILE (file), FALSE); if (!g_file_query_exists (file, NULL)) { g_set_error_literal (error, TRACKER_MINER_MANAGER_ERROR, TRACKER_MINER_MANAGER_ERROR_NOENT, "File or directory does not exist"); return FALSE; } if (!tracker_miner_manager_is_active (manager, "org.freedesktop.Tracker1.Miner.Files")) { g_set_error_literal (error, TRACKER_MINER_MANAGER_ERROR, TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE, "Filesystem miner is not active"); return FALSE; } priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager); uri = g_file_get_uri (file); v = g_dbus_connection_call_sync (priv->connection, "org.freedesktop.Tracker1.Miner.Files.Index", "/org/freedesktop/Tracker1/Miner/Files/Index", "org.freedesktop.Tracker1.Miner.Files.Index", "IndexFile", g_variant_new ("(s)", uri), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &new_error); g_free (uri); if (new_error) { g_propagate_error (error, new_error); return FALSE; } g_variant_unref (v); return FALSE; }
/** * tracker_miner_manager_index_file: * @manager: a #TrackerMinerManager * @file: a URL valid in GIO of a file to give to the miner for processing * @error: (out callee-allocates) (transfer full) (allow-none): return location for errors * * Tells the filesystem miner to start indexing the @file. * * On failure @error will be set. * * Returns: %TRUE on success, otherwise %FALSE. * * Since: 0.10 **/ gboolean tracker_miner_manager_index_file (TrackerMinerManager *manager, GFile *file, GError **error) { g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (G_IS_FILE (file), FALSE); return miner_manager_index_file_sync (manager, file, NULL, error); }
/** * tracker_miner_manager_pause_for_process: * @manager: a #TrackerMinerManager. * @miner: miner reference * @reason: reason to pause * @cookie: (out) (allow-none): return location for the pause cookie ID * * This function operates exactly the same way as * tracker_miner_manager_pause() with the exception that if the calling * process dies, the pause is resumed. This API is useful for cases * where the calling process has a risk of crashing without resuming * the pause. * * NOTE: If you call g_object_unref() on the @manager before you * intend to resume the pause and it finalizes, it will automatically * resume. * * Returns: %TRUE if the miner was paused successfully, otherwise * %FALSE. * * Since: 0.10.15 **/ gboolean tracker_miner_manager_pause_for_process (TrackerMinerManager *manager, const gchar *miner, const gchar *reason, guint32 *cookie) { GDBusProxy *proxy; const gchar *app_name; GError *error = NULL; GVariant *v; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (miner != NULL, FALSE); g_return_val_if_fail (reason != NULL, FALSE); proxy = find_miner_proxy (manager, miner, TRUE); if (!proxy) { g_critical ("No D-Bus proxy found for miner '%s'", miner); return FALSE; } /* Find a reasonable app name */ app_name = g_get_application_name (); if (!app_name) { app_name = g_get_prgname (); } if (!app_name) { app_name = "TrackerMinerManager client"; } v = g_dbus_proxy_call_sync (proxy, "PauseForProcess", g_variant_new ("(ss)", app_name, reason), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not pause miner '%s': %s", miner, error->message); g_error_free (error); return FALSE; } if (cookie) { g_variant_get (v, "(i)", cookie); } g_variant_unref (v); return TRUE; }
/** * tracker_miner_manager_reindex_by_mimetype: * @manager: a #TrackerMinerManager * @mimetypes: (in): an array of mimetypes (E.G. "text/plain"). All items * with a mimetype in that list will be reindexed. * @error: (out callee-allocates) (transfer full) (allow-none): return location for errors * * Tells the filesystem miner to reindex any file with a mimetype in * the @mimetypes list. * * On failure @error will be set. * * Returns: %TRUE on success, otherwise %FALSE. * * Since: 0.10 **/ gboolean tracker_miner_manager_reindex_by_mimetype (TrackerMinerManager *manager, const GStrv mimetypes, GError **error) { TrackerMinerManagerPrivate *priv; GVariant *v; GError *new_error = NULL; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (mimetypes != NULL, FALSE); if (!tracker_miner_manager_is_active (manager, "org.freedesktop.Tracker1.Miner.Files")) { g_set_error_literal (error, TRACKER_MINER_MANAGER_ERROR, TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE, "Filesystem miner is not active"); return FALSE; } priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager); v = g_dbus_connection_call_sync (priv->connection, "org.freedesktop.Tracker1.Miner.Files.Index", "/org/freedesktop/Tracker1/Miner/Files/Index", "org.freedesktop.Tracker1.Miner.Files.Index", "ReindexMimeTypes", g_variant_new ("(^as)", mimetypes), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &new_error); if (new_error) { g_propagate_error (error, new_error); return FALSE; } g_variant_unref (v); return FALSE; }
/** * tracker_miner_manager_get_description: * @manager: a #TrackerMinerManager * @miner: miner reference * * Returns the description for the given @miner. * * Returns: (transfer none): A string which should not be freed or %NULL if none is specified. * * Since: 0.8 **/ const gchar * tracker_miner_manager_get_description (TrackerMinerManager *manager, const gchar *miner) { TrackerMinerManagerPrivate *priv; GList *m; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), NULL); g_return_val_if_fail (miner != NULL, NULL); priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager); for (m = priv->miners; m; m = m->next) { MinerData *data = m->data; if (strcmp (miner, data->dbus_name) == 0) { return data->description; } } return NULL; }
/** * tracker_miner_manager_is_active: * @manager: a #TrackerMinerManager * @miner: miner reference * * Returns the miner's current activity. * * Returns: %TRUE if the @miner is active, otherwise %FALSE. * * Since: 0.8 **/ gboolean tracker_miner_manager_is_active (TrackerMinerManager *manager, const gchar *miner) { TrackerMinerManagerPrivate *priv; GError *error = NULL; gboolean active = FALSE; GVariant *v; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (miner != NULL, FALSE); priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager); v = g_dbus_connection_call_sync (priv->connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "NameHasOwner", g_variant_new ("(s)", miner), (GVariantType *) "(b)", G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not check whether miner '%s' is currently active: %s", miner, error ? error->message : "no error given"); g_error_free (error); return FALSE; } g_variant_get (v, "(b)", &active); g_variant_unref (v); return active; }
/** * tracker_miner_manager_ignore_next_update: * @manager: a #TrackerMinerManager * @miner: miner reference * @urls: (in): the subjects to ignore the next updates of * * Tells the @miner to ignore any events for the next @urls. This is * used for cases where a file is updated by Tracker by the * tracker-writeback service. This API is used to avoid signalling up * the stack the changes to @urls. * * Returns: %TRUE on success, otherwise %FALSE. * * Since: 0.8 * * Deprecated: 0.12 **/ gboolean tracker_miner_manager_ignore_next_update (TrackerMinerManager *manager, const gchar *miner, const gchar **urls) { GDBusProxy *proxy; GError *error = NULL; GVariant *v; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (miner != NULL, FALSE); proxy = find_miner_proxy (manager, miner, TRUE); if (!proxy) { g_warning ("No D-Bus proxy found for miner '%s'", miner); return FALSE; } v = g_dbus_proxy_call_sync (proxy, "IgnoreNextUpdate", g_variant_new ("(^as)", urls), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_warning ("Could not ignore next update for miner '%s': %s", miner, error->message); g_error_free (error); return FALSE; } g_variant_unref (v); return TRUE; }
/** * tracker_miner_manager_resume: * @manager: a #TrackerMinerManager * @miner: miner reference * @cookie: pause cookie * * Tells @miner to resume activity. The miner won't actually resume * operations until all pause requests have been resumed. * * Returns: %TRUE if the miner was successfully resumed, otherwise * %FALSE. * * Since: 0.8 **/ gboolean tracker_miner_manager_resume (TrackerMinerManager *manager, const gchar *miner, guint32 cookie) { GDBusProxy *proxy; GError *error = NULL; GVariant *v; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (miner != NULL, FALSE); proxy = find_miner_proxy (manager, miner, TRUE); if (!proxy) { g_critical ("No D-Bus proxy found for miner '%s'", miner); return FALSE; } v = g_dbus_proxy_call_sync (proxy, "Resume", g_variant_new ("(i)", (gint) cookie), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not resume miner '%s': %s", miner, error->message); g_error_free (error); return FALSE; } g_variant_unref (v); return TRUE; }
/** * tracker_miner_manager_is_paused: * @manager: a #TrackerMinerManager * @miner: miner reference * @applications: (out callee-allocates) (allow-none) (transfer full): * return location for application names. * @reasons: (out callee-allocates) (allow-none) (transfer full): * return location for pause reasons. * * This function either returns %FALSE if the miner is not paused, * or returns %TRUE and fills in @applications and @reasons with * the pause reasons and the applications that asked for it. Both * arrays will have the same lengh, and will be sorted so the * application/pause reason pairs have the same index. * * Returns: %TRUE if @miner is paused, otherwise %FALSE. * * Since: 0.8 **/ gboolean tracker_miner_manager_is_paused (TrackerMinerManager *manager, const gchar *miner, GStrv *applications, GStrv *reasons) { GDBusProxy *proxy; GStrv apps, r; GError *error = NULL; gboolean paused; GVariant *v; if (applications) { *applications = NULL; } if (reasons) { *reasons = NULL; } g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), TRUE); g_return_val_if_fail (miner != NULL, TRUE); proxy = find_miner_proxy (manager, miner, TRUE); if (!proxy) { g_critical ("No D-Bus proxy found for miner '%s'", miner); return FALSE; } v = g_dbus_proxy_call_sync (proxy, "GetPauseDetails", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not get pause details for miner '%s': %s", miner, error->message); g_error_free (error); return FALSE; } g_variant_get (v, "(^as^as)", &apps, &r); g_variant_unref (v); paused = (g_strv_length (apps) > 0); if (applications) { *applications = apps; } else { g_strfreev (apps); } if (reasons) { *reasons = r; } else { g_strfreev (r); } return paused; }
/** * tracker_miner_manager_get_status: * @manager: a #TrackerMinerManager * @miner: miner reference * @status: (out) (allow-none): return location for status * @progress: (out) (allow-none): return location for progress * @remaining_time: (out) (allow-none): return location for remaining time * * Returns the current status, progress and remaining time for @miner. * @remaining_time will be 0 if not possible to compute it yet, * and less than zero if it is not applicable. * * Returns: %TRUE if the status could be retrieved successfully, * otherwise %FALSE * * Since: 0.12 **/ gboolean tracker_miner_manager_get_status (TrackerMinerManager *manager, const gchar *miner, gchar **status, gdouble *progress, gint *remaining_time) { GDBusProxy *proxy; g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE); g_return_val_if_fail (miner != NULL, FALSE); /* At least one of them should be asked */ g_return_val_if_fail (status != NULL || progress != NULL || remaining_time != NULL, FALSE); proxy = find_miner_proxy (manager, miner, TRUE); if (!proxy) { g_critical ("No D-Bus proxy found for miner '%s'", miner); return FALSE; } if (progress) { GError *error = NULL; GVariant *v; v = g_dbus_proxy_call_sync (proxy, "GetProgress", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { /* We handle this error as a special case, some * plugins don't have .service files. */ if (error->code != G_DBUS_ERROR_SERVICE_UNKNOWN) { g_critical ("Could not get miner progress for '%s': %s", miner, error->message); } g_error_free (error); return FALSE; } g_variant_get (v, "(d)", progress); g_variant_unref (v); } if (status) { GError *error = NULL; GVariant *v; v = g_dbus_proxy_call_sync (proxy, "GetStatus", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not get miner status for '%s': %s", miner, error->message); g_error_free (error); return FALSE; } g_variant_get (v, "(s)", status); g_variant_unref (v); } if (remaining_time) { GError *error = NULL; GVariant *v; v = g_dbus_proxy_call_sync (proxy, "GetRemainingTime", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { g_critical ("Could not get miner remaining processing " "time for '%s': %s", miner, error->message); g_error_free (error); return FALSE; } g_variant_get (v, "(i)", remaining_time); g_variant_unref (v); } return TRUE; }