tracker_miner_manager_error_quark ()

GQuark
tracker_miner_manager_error_quark (void);

Since: 0.8

tracker_miner_manager_new ()

TrackerMinerManager *
tracker_miner_manager_new (void);

Creates a new TrackerMinerManager instance.

Note: Auto-starting miners when querying status will be enabled.

Since: 0.8

tracker_miner_manager_new_full ()

TrackerMinerManager *
tracker_miner_manager_new_full (gboolean auto_start,
                                GError **error);

Creates a new TrackerMinerManager.

Since: 0.10.5

tracker_miner_manager_get_running ()

GSList *
tracker_miner_manager_get_running (TrackerMinerManager *manager);

Returns a list of references for all active miners. Active miners are miners which are running within a process.

Since: 0.8

tracker_miner_manager_get_available ()

GSList *
tracker_miner_manager_get_available (TrackerMinerManager *manager);

Returns a list of references for all available miners. Available miners are miners which may or may not be running in a process at the current time.

Since: 0.8

tracker_miner_manager_pause ()

gboolean
tracker_miner_manager_pause (TrackerMinerManager *manager,
                             const gchar *miner,
                             const gchar *reason,
                             guint32 *cookie);

Asks miner to pause. a miner could be paused by several reasons, and its activity won't be resumed until all pause requests have been resumed.

Since: 0.8

tracker_miner_manager_pause_for_process ()

gboolean
tracker_miner_manager_pause_for_process
                               (TrackerMinerManager *manager,
                                const gchar *miner,
                                const gchar *reason,
                                guint32 *cookie);

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.

Since: 0.10.15

tracker_miner_manager_resume ()

gboolean
tracker_miner_manager_resume (TrackerMinerManager *manager,
                              const gchar *miner,
                              guint32 cookie);

Tells miner to resume activity. The miner won't actually resume operations until all pause requests have been resumed.

Since: 0.8

tracker_miner_manager_is_active ()

gboolean
tracker_miner_manager_is_active (TrackerMinerManager *manager,
                                 const gchar *miner);

Returns the miner's current activity.

Since: 0.8

tracker_miner_manager_is_paused ()

gboolean
tracker_miner_manager_is_paused (TrackerMinerManager *manager,
                                 const gchar *miner,
                                 GStrv *applications,
                                 GStrv *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.

Since: 0.8

tracker_miner_manager_get_status ()

gboolean
tracker_miner_manager_get_status (TrackerMinerManager *manager,
                                  const gchar *miner,
                                  gchar **status,
                                  gdouble *progress,
                                  gint *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.

Since: 0.12

tracker_miner_manager_get_display_name ()

const gchar *
tracker_miner_manager_get_display_name
                               (TrackerMinerManager *manager,
                                const gchar *miner);

Returns a translated display name for miner .

Since: 0.8

tracker_miner_manager_get_description ()

const gchar *
tracker_miner_manager_get_description (TrackerMinerManager *manager,
                                       const gchar *miner);

Returns the description for the given miner .

Since: 0.8

tracker_miner_manager_reindex_by_mimetype ()

gboolean
tracker_miner_manager_reindex_by_mimetype
                               (TrackerMinerManager *manager,
                                const GStrv mimetypes,
                                GError **error);

Tells the filesystem miner to reindex any file with a mimetype in the mimetypes list.

On failure error will be set.

Since: 0.10

tracker_miner_manager_index_file ()

gboolean
tracker_miner_manager_index_file (TrackerMinerManager *manager,
                                  GFile *file,
                                  GCancellable *cancellable,
                                  GError **error);

Tells the filesystem miner to start indexing the file .

On failure error will be set.

Since: 2.0

tracker_miner_manager_index_file_async ()

void
tracker_miner_manager_index_file_async
                               (TrackerMinerManager *manager,
                                GFile *file,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Tells the filesystem miner to start indexing the file . Once the message has been sent, callback will be called. You can then call tracker_miner_manager_index_file_finish() to get the result.

Since: 0.16

tracker_miner_manager_index_file_finish ()

gboolean
tracker_miner_manager_index_file_finish
                               (TrackerMinerManager *manager,
                                GAsyncResult *result,
                                GError **error);

Finishes a request to index a file. See tracker_miner_manager_index_file_async()

On failure error will be set.

Since: 0.16

tracker_miner_manager_index_file_for_process ()

gboolean
tracker_miner_manager_index_file_for_process
                               (TrackerMinerManager *manager,
                                GFile *file,
                                GCancellable *cancellable,
                                GError **error);

This function operates exactly the same way as tracker_miner_manager_index_file() with the exception that if the calling process dies, the indexing is cancelled. This API is useful for cases where the calling process wants to tie the indexing operation closely to its own lifetime.

On failure error will be set.

Since: 1.10

tracker_miner_manager_index_file_for_process_async ()

void
tracker_miner_manager_index_file_for_process_async
                               (TrackerMinerManager *manager,
                                GFile *file,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

This function operates exactly the same way as tracker_miner_manager_index_file() with the exception that if the calling process dies, the indexing is cancelled. This API is useful for cases where the calling process wants to tie the indexing operation closely to its own lifetime.

When the operation is finished, callback will be called. You can then call tracker_miner_manager_index_file_for_process_finish() to get the result of the operation.

Since: 1.10

tracker_miner_manager_index_file_for_process_finish ()

gboolean
tracker_miner_manager_index_file_for_process_finish
                               (TrackerMinerManager *manager,
                                GAsyncResult *result,
                                GError **error);

Finishes a request to index a file. See tracker_miner_manager_index_file_for_process_async()

On failure error will be set.

Since: 1.10

TRACKER_MINER_MANAGER_ERROR

#define TRACKER_MINER_MANAGER_ERROR tracker_miner_manager_error_quark ()

enum TrackerMinerManagerError

Enumeration values used in errors returned by the TrackerMinerManager API.

Since: 0.8

struct TrackerMinerManager

struct TrackerMinerManager;

Object to query and control miners.

TrackerMinerManagerClass

typedef struct {
	GObjectClass parent_class;

	void (* miner_progress)    (TrackerMinerManager *manager,
	                            const gchar         *miner_name,
	                            const gchar         *status,
	                            gdouble              progress);
	void (* miner_paused)      (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
	void (* miner_resumed)     (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
	void (* miner_activated)   (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
	void (* miner_deactivated) (TrackerMinerManager *manager,
	                            const gchar         *miner_name);
} TrackerMinerManagerClass;

The “auto-start” property

  “auto-start”               gboolean

If set, auto starts miners when querying their status.

Flags: Read / Write / Construct Only

Default value: TRUE

The “domain-ontology” property

  “domain-ontology”          gchar *

The domain ontology this object controls.

Flags: Read / Write / Construct Only

Default value: NULL

The “miner-activated” signal

void
user_function (TrackerMinerManager *manager,
               gchar               *miner,
               gpointer             user_data)

The ::miner-activated signal will be emitted whenever a miner (referenced by miner ) is activated (technically, this means the miner has appeared in the session bus).

Flags: Run Last

Since: 0.8

The “miner-deactivated” signal

void
user_function (TrackerMinerManager *manager,
               gchar               *miner,
               gpointer             user_data)

The ::miner-deactivated signal will be emitted whenever a miner (referenced by miner ) is deactivated (technically, this means the miner has disappeared from the session bus).

Flags: Run Last

Since: 0.8

The “miner-paused” signal

void
user_function (TrackerMinerManager *manager,
               gchar               *miner,
               gpointer             user_data)

The ::miner-paused signal will be emitted whenever a miner (referenced by miner ) is paused.

Flags: Run Last

Since: 0.8

The “miner-progress” signal

void
user_function (TrackerMinerManager *manager,
               gchar               *miner,
               gchar               *status,
               gdouble              progress,
               gint                 remaining_time,
               gpointer             user_data)

The ::miner-progress signal is meant to report status/progress changes in any tracked miner.

Flags: Run Last

Since: 0.12

The “miner-resumed” signal

void
user_function (TrackerMinerManager *manager,
               gchar               *miner,
               gpointer             user_data)

The ::miner-resumed signal will be emitted whenever a miner (referenced by miner ) is resumed.

Flags: Run Last

Since: 0.8