[tracker/sam/index-mount-points-2: 2/3] tracker-miner-fs: Keep cache of IndexFile requesters on directories
- From: Sam Thursfield <sthursfield src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [tracker/sam/index-mount-points-2: 2/3] tracker-miner-fs: Keep cache of IndexFile requesters on directories
- Date: Tue, 18 Aug 2015 21:32:19 +0000 (UTC)
commit 7f6b036c7136366a9533b8482bdedfb8958d83a3
Author: Carlos Garnacho <carlosg gnome org>
Date: Sat Aug 15 00:08:11 2015 +0200
tracker-miner-fs: Keep cache of IndexFile requesters on directories
The senders for all DBus requests to the IndexFile method on directories
will be now watched, the dbus presence of the senders will control the
lifetime of the directory on the indexed directories tree.
There may be multiple requests on a same directory, in such case the
directory will be indexed/monitored for as long as there is alive requesters
on it. Requests on already indexed directories (or children of recursively
indexed ones) will be silently ignored. Unmounts will also silently drop
the IndexFile listeners, applications should issue new requests on volume
mounts if desired.
The patch is loosely based on initial work from Felipe Borges.
https://bugzilla.gnome.org/show_bug.cgi?id=680834
src/miners/fs/Makefile.am | 2 +
src/miners/fs/tracker-miner-files-index.c | 60 +++-
src/miners/fs/tracker-miner-files-peer-listener.c | 447 +++++++++++++++++++++
src/miners/fs/tracker-miner-files-peer-listener.h | 65 +++
4 files changed, 573 insertions(+), 1 deletions(-)
---
diff --git a/src/miners/fs/Makefile.am b/src/miners/fs/Makefile.am
index c766a60..27bd016 100644
--- a/src/miners/fs/Makefile.am
+++ b/src/miners/fs/Makefile.am
@@ -34,6 +34,8 @@ tracker_miner_fs_SOURCES = \
tracker-miner-files.h \
tracker-miner-files-index.c \
tracker-miner-files-index.h \
+ tracker-miner-files-peer-listener.c \
+ tracker-miner-files-peer-listener.h \
tracker-storage.c \
tracker-storage.h \
tracker-writeback-listener.c \
diff --git a/src/miners/fs/tracker-miner-files-index.c b/src/miners/fs/tracker-miner-files-index.c
index b507e32..a427041 100644
--- a/src/miners/fs/tracker-miner-files-index.c
+++ b/src/miners/fs/tracker-miner-files-index.c
@@ -24,6 +24,7 @@
#include <libtracker-miner/tracker-miner.h>
#include "tracker-miner-files-index.h"
+#include "tracker-miner-files-peer-listener.h"
static const gchar introspection_xml[] =
@@ -54,6 +55,7 @@ typedef struct {
typedef struct {
TrackerMinerFiles *files_miner;
+ TrackerMinerFilesPeerListener *peer_listener;
GDBusConnection *d_connection;
GDBusNodeInfo *introspection_data;
guint registration_id;
@@ -161,6 +163,7 @@ index_finalize (GObject *object)
g_object_unref (priv->d_connection);
}
+ g_clear_object (&priv->peer_listener);
g_free (priv->full_name);
g_free (priv->full_path);
@@ -365,7 +368,29 @@ handle_method_call_index_file (TrackerMinerFilesIndex *miner,
#endif /* REQUIRE_LOCATION_IN_CONFIG */
if (is_dir) {
- tracker_miner_fs_check_directory (TRACKER_MINER_FS (priv->files_miner), file, do_checks);
+ TrackerIndexingTree *indexing_tree;
+ TrackerDirectoryFlags flags;
+ gboolean is_watched, needs_watch = FALSE;
+ GFile *root;
+
+ indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (priv->files_miner));
+ root = tracker_indexing_tree_get_root (indexing_tree, file, &flags);
+ is_watched = tracker_miner_files_peer_listener_is_file_watched (priv->peer_listener, file);
+
+ if (!root || !(flags & TRACKER_DIRECTORY_FLAG_RECURSE)) {
+ tracker_indexing_tree_add (indexing_tree, file,
+ TRACKER_DIRECTORY_FLAG_RECURSE |
+ TRACKER_DIRECTORY_FLAG_PRIORITY |
+ TRACKER_DIRECTORY_FLAG_CHECK_MTIME |
+ TRACKER_DIRECTORY_FLAG_MONITOR);
+ needs_watch = TRUE;
+ }
+
+ if (is_watched || needs_watch) {
+ tracker_miner_files_peer_listener_add_watch (priv->peer_listener,
+ g_dbus_method_invocation_get_sender
(invocation),
+ file);
+ }
} else {
tracker_miner_fs_check_file (TRACKER_MINER_FS (priv->files_miner), file, do_checks);
}
@@ -400,6 +425,30 @@ handle_method_call (GDBusConnection *connection,
}
}
+static void
+peer_listener_unwatch_file (TrackerMinerFilesPeerListener *listener,
+ GFile *file,
+ gpointer user_data)
+{
+ TrackerMinerFilesIndexPrivate *priv;
+ TrackerIndexingTree *indexing_tree;
+
+ priv = TRACKER_MINER_FILES_INDEX_GET_PRIVATE (user_data);
+ indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (priv->files_miner));
+ tracker_indexing_tree_remove (indexing_tree, file);
+}
+
+static void
+indexing_tree_directory_remove (TrackerIndexingTree *indexing_tree,
+ GFile *file,
+ gpointer user_data)
+{
+ TrackerMinerFilesIndexPrivate *priv;
+
+ priv = TRACKER_MINER_FILES_INDEX_GET_PRIVATE (user_data);
+ tracker_miner_files_peer_listener_remove_file (priv->peer_listener, file);
+}
+
static GVariant *
handle_get_property (GDBusConnection *connection,
const gchar *sender,
@@ -441,6 +490,7 @@ tracker_miner_files_index_new (TrackerMinerFiles *miner_files)
GVariant *reply;
guint32 rval;
GError *error = NULL;
+ TrackerIndexingTree *indexing_tree;
GDBusInterfaceVTable interface_vtable = {
handle_method_call,
handle_get_property,
@@ -530,5 +580,13 @@ tracker_miner_files_index_new (TrackerMinerFiles *miner_files)
priv->full_path = full_path;
+ priv->peer_listener = tracker_miner_files_peer_listener_new (priv->d_connection);
+ g_signal_connect (priv->peer_listener, "unwatch-file",
+ G_CALLBACK (peer_listener_unwatch_file), miner);
+
+ indexing_tree = tracker_miner_fs_get_indexing_tree (TRACKER_MINER_FS (miner_files));
+ g_signal_connect (indexing_tree, "directory-removed",
+ G_CALLBACK (indexing_tree_directory_remove), miner);
+
return (TrackerMinerFilesIndex *) miner;
}
diff --git a/src/miners/fs/tracker-miner-files-peer-listener.c
b/src/miners/fs/tracker-miner-files-peer-listener.c
new file mode 100644
index 0000000..1b5c293
--- /dev/null
+++ b/src/miners/fs/tracker-miner-files-peer-listener.c
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2015, Carlos Garnacho
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Author: Carlos Garnacho <carlosg gnome org>
+ */
+
+#include "tracker-miner-files-peer-listener.h"
+
+enum {
+ PROP_CONNECTION = 1
+};
+
+enum {
+ WATCH_FILE,
+ UNWATCH_FILE,
+ N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0 };
+
+typedef struct {
+ gchar *dbus_name;
+ GPtrArray *files; /* Array of GFiles, actually owned by FilePeersData */
+ guint watch_id;
+} PeerFilesData;
+
+typedef struct {
+ GFile *file;
+ GPtrArray *peers; /* Array of dbus names, actually owned by PeerFilesData */
+} FilePeersData;
+
+typedef struct {
+ GDBusConnection *d_connection;
+ GHashTable *peer_files; /* dbus name -> PeerFilesData */
+ GHashTable *file_peers; /* GFile -> FilePeersData */
+} TrackerMinerFilesPeerListenerPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (TrackerMinerFilesPeerListener,
+ tracker_miner_files_peer_listener,
+ G_TYPE_OBJECT)
+
+static void
+on_app_disappeared_cb (GDBusConnection *conn,
+ const gchar *dbus_name,
+ gpointer user_data)
+{
+ TrackerMinerFilesPeerListener *listener = user_data;
+
+ tracker_miner_files_peer_listener_remove_dbus_name (listener, dbus_name);
+}
+
+static PeerFilesData *
+peer_files_data_new (const gchar *dbus_name,
+ TrackerMinerFilesPeerListener *listener)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ PeerFilesData *data;
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ data = g_slice_new0 (PeerFilesData);
+ data->dbus_name = g_strdup (dbus_name);
+ data->files = g_ptr_array_new ();
+ data->watch_id = g_bus_watch_name_on_connection (priv->d_connection,
+ dbus_name, 0, NULL,
+ on_app_disappeared_cb,
+ listener, NULL);
+ return data;
+}
+
+static void
+peer_files_data_free (PeerFilesData *data)
+{
+ g_bus_unwatch_name (data->watch_id);
+ g_ptr_array_unref (data->files);
+ g_free (data->dbus_name);
+ g_slice_free (PeerFilesData, data);
+}
+
+static void
+peer_files_data_add_file (PeerFilesData *data,
+ GFile *file)
+{
+ g_ptr_array_add (data->files, file);
+}
+
+static void
+peer_files_data_remove_file (PeerFilesData *data,
+ GFile *file)
+{
+ gint i;
+
+ for (i = 0; i < data->files->len; i++) {
+ if (file != g_ptr_array_index (data->files, i))
+ continue;
+
+ g_ptr_array_remove_index (data->files, i);
+ break;
+ }
+}
+
+static FilePeersData *
+file_peers_data_new (GFile *file)
+{
+ FilePeersData *data;
+
+ g_return_val_if_fail (G_IS_FILE (file), NULL);
+
+ data = g_slice_new0 (FilePeersData);
+ data->file = g_object_ref (file);
+ data->peers = g_ptr_array_new ();
+
+ return data;
+}
+
+static void
+file_peers_data_free (FilePeersData *data)
+{
+ g_object_unref (data->file);
+ g_ptr_array_unref (data->peers);
+ g_slice_free (FilePeersData, data);
+}
+
+static void
+file_peers_data_add_dbus_name (FilePeersData *data,
+ gchar *dbus_name)
+{
+ g_ptr_array_add (data->peers, dbus_name);
+}
+
+static void
+file_peers_data_remove_dbus_name (FilePeersData *data,
+ gchar *dbus_name)
+{
+ gint i;
+
+ for (i = 0; i < data->peers->len; i++) {
+ if (dbus_name != g_ptr_array_index (data->peers, i))
+ continue;
+
+ g_ptr_array_remove_index (data->peers, i);
+ break;
+ }
+}
+
+static void
+tracker_miner_files_peer_listener_finalize (GObject *object)
+{
+ TrackerMinerFilesPeerListener *listener;
+ TrackerMinerFilesPeerListenerPrivate *priv;
+
+ listener = TRACKER_MINER_FILES_PEER_LISTENER (object);
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+ g_hash_table_destroy (priv->peer_files);
+ g_hash_table_destroy (priv->file_peers);
+ g_object_unref (priv->d_connection);
+
+ G_OBJECT_CLASS (tracker_miner_files_peer_listener_parent_class)->finalize (object);
+}
+
+static void
+tracker_miner_files_peer_listener_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ TrackerMinerFilesPeerListener *listener;
+
+ listener = TRACKER_MINER_FILES_PEER_LISTENER (object);
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ switch (prop_id) {
+ case PROP_CONNECTION:
+ priv->d_connection = g_value_dup_object (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+tracker_miner_files_peer_listener_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ TrackerMinerFilesPeerListener *listener;
+
+ listener = TRACKER_MINER_FILES_PEER_LISTENER (object);
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ switch (prop_id) {
+ case PROP_CONNECTION:
+ g_value_set_object (value, priv->d_connection);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+tracker_miner_files_peer_listener_class_init (TrackerMinerFilesPeerListenerClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = tracker_miner_files_peer_listener_finalize;
+ object_class->set_property = tracker_miner_files_peer_listener_set_property;
+ object_class->get_property = tracker_miner_files_peer_listener_get_property;
+
+ g_object_class_install_property (object_class,
+ PROP_CONNECTION,
+ g_param_spec_object ("connection",
+ "Connection",
+ "Connection",
+ G_TYPE_DBUS_CONNECTION,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ signals[WATCH_FILE] =
+ g_signal_new ("watch-file",
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST, 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 1, G_TYPE_FILE);
+ signals[UNWATCH_FILE] =
+ g_signal_new ("unwatch-file",
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST, 0,
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 1, G_TYPE_FILE);
+}
+
+static void
+tracker_miner_files_peer_listener_init (TrackerMinerFilesPeerListener *listener)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+ priv->peer_files = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
+ (GDestroyNotify) peer_files_data_free);
+ priv->file_peers = g_hash_table_new_full (g_file_hash,
+ (GEqualFunc) g_file_equal, NULL,
+ (GDestroyNotify) file_peers_data_free);
+}
+
+TrackerMinerFilesPeerListener *
+tracker_miner_files_peer_listener_new (GDBusConnection *connection)
+{
+ return g_object_new (TRACKER_TYPE_MINER_FILES_PEER_LISTENER,
+ "connection", connection,
+ NULL);
+}
+
+static void
+unwatch_file (TrackerMinerFilesPeerListener *listener,
+ GFile *file)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ g_object_ref (file);
+ g_hash_table_remove (priv->file_peers, file);
+ g_signal_emit (listener, signals[UNWATCH_FILE], 0, file);
+ g_object_unref (file);
+}
+
+void
+tracker_miner_files_peer_listener_add_watch (TrackerMinerFilesPeerListener *listener,
+ const gchar *dbus_name,
+ GFile *file)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ PeerFilesData *peer_data;
+ FilePeersData *file_data;
+
+ g_return_if_fail (TRACKER_IS_MINER_FILES_PEER_LISTENER (listener));
+ g_return_if_fail (G_IS_FILE (file));
+ g_return_if_fail (dbus_name != NULL);
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ peer_data = g_hash_table_lookup (priv->peer_files, dbus_name);
+ file_data = g_hash_table_lookup (priv->file_peers, file);
+
+ if (!peer_data) {
+ peer_data = peer_files_data_new (dbus_name, listener);
+ g_hash_table_insert (priv->peer_files,
+ peer_data->dbus_name, peer_data);
+ }
+
+ if (!file_data) {
+ gchar *uri;
+
+ file_data = file_peers_data_new (file);
+ g_hash_table_insert (priv->file_peers,
+ file_data->file, file_data);
+ g_signal_emit (listener, signals[WATCH_FILE], 0, file_data->file);
+
+ uri = g_file_get_uri (file);
+ g_debug ("Client '%s' requests watch on '%s'", dbus_name, uri);
+ g_free (uri);
+ }
+
+ peer_files_data_add_file (peer_data, file_data->file);
+ file_peers_data_add_dbus_name (file_data, peer_data->dbus_name);
+}
+
+void
+tracker_miner_files_peer_listener_remove_watch (TrackerMinerFilesPeerListener *listener,
+ const gchar *dbus_name,
+ GFile *file)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ PeerFilesData *peer_data;
+ FilePeersData *file_data;
+
+ g_return_if_fail (TRACKER_IS_MINER_FILES_PEER_LISTENER (listener));
+ g_return_if_fail (G_IS_FILE (file));
+ g_return_if_fail (dbus_name != NULL);
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ peer_data = g_hash_table_lookup (priv->peer_files, dbus_name);
+ file_data = g_hash_table_lookup (priv->file_peers, file);
+
+ if (!file_data || !peer_data)
+ return;
+
+ peer_files_data_remove_file (peer_data, file_data->file);
+ file_peers_data_remove_dbus_name (file_data, peer_data->dbus_name);
+
+ if (peer_data->files->len == 0)
+ g_hash_table_remove (priv->peer_files, peer_data->dbus_name);
+
+ if (file_data->peers->len == 0)
+ unwatch_file (listener, file_data->file);
+}
+
+void
+tracker_miner_files_peer_listener_remove_dbus_name (TrackerMinerFilesPeerListener *listener,
+ const gchar *dbus_name)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ PeerFilesData *peer_data;
+ FilePeersData *file_data;
+ GFile *file;
+ gint i;
+
+ g_return_if_fail (TRACKER_IS_MINER_FILES_PEER_LISTENER (listener));
+ g_return_if_fail (dbus_name != NULL);
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+ peer_data = g_hash_table_lookup (priv->peer_files, dbus_name);
+
+ if (!peer_data)
+ return;
+
+ g_debug ("Removing all watches from client '%s'", dbus_name);
+
+ for (i = 0; i < peer_data->files->len; i++) {
+ file = g_ptr_array_index (peer_data->files, i);
+ file_data = g_hash_table_lookup (priv->file_peers, file);
+
+ if (!file_data)
+ continue;
+
+ file_peers_data_remove_dbus_name (file_data, peer_data->dbus_name);
+
+ if (file_data->peers->len == 0)
+ unwatch_file (listener, file_data->file);
+ }
+
+ g_hash_table_remove (priv->peer_files, dbus_name);
+}
+
+void
+tracker_miner_files_peer_listener_remove_file (TrackerMinerFilesPeerListener *listener,
+ GFile *file)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+ PeerFilesData *peer_data;
+ FilePeersData *file_data;
+ const gchar *dbus_name;
+ gchar *uri;
+ gint i;
+
+ g_return_if_fail (TRACKER_IS_MINER_FILES_PEER_LISTENER (listener));
+ g_return_if_fail (G_IS_FILE (file));
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+ file_data = g_hash_table_lookup (priv->file_peers, file);
+
+ if (!file_data || file_data->peers->len == 0)
+ return;
+
+ uri = g_file_get_uri (file);
+ g_debug ("Removing client listeners for file '%s'", uri);
+ g_free (uri);
+
+ for (i = 0; i < file_data->peers->len; i++) {
+ dbus_name = g_ptr_array_index (file_data->peers, i);
+ peer_data = g_hash_table_lookup (priv->peer_files, dbus_name);
+
+ if (!peer_data)
+ continue;
+
+ peer_files_data_remove_file (peer_data, file_data->file);
+
+ if (peer_data->files->len == 0)
+ g_hash_table_remove (priv->peer_files, dbus_name);
+ }
+
+ unwatch_file (listener, file);
+}
+
+gboolean
+tracker_miner_files_peer_listener_is_file_watched (TrackerMinerFilesPeerListener *listener,
+ GFile *file)
+{
+ TrackerMinerFilesPeerListenerPrivate *priv;
+
+ g_return_if_fail (TRACKER_IS_MINER_FILES_PEER_LISTENER (listener));
+ g_return_if_fail (G_IS_FILE (file));
+
+ priv = tracker_miner_files_peer_listener_get_instance_private (listener);
+
+ return g_hash_table_lookup (priv->file_peers, file) != NULL;
+}
diff --git a/src/miners/fs/tracker-miner-files-peer-listener.h
b/src/miners/fs/tracker-miner-files-peer-listener.h
new file mode 100644
index 0000000..7a23d32
--- /dev/null
+++ b/src/miners/fs/tracker-miner-files-peer-listener.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2015, Carlos Garnacho
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ * Author: Carlos Garnacho <carlosg gnome org>
+ */
+
+#ifndef __TRACKER_MINER_FILES_PEER_LISTENER_H__
+#define __TRACKER_MINER_FILES_PEER_LISTENER_H__
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#define TRACKER_TYPE_MINER_FILES_PEER_LISTENER (tracker_miner_files_peer_listener_get_type ())
+#define TRACKER_MINER_FILES_PEER_LISTENER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object),
TRACKER_TYPE_MINER_FILES_PEER_LISTENER, TrackerMinerFilesPeerListener))
+#define TRACKER_MINER_FILES_PEER_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass),
TRACKER_TYPE_DBUS_MINER_FILES_PEER_LISTENER, TrackerMinerFilesPeerListenerClass))
+#define TRACKER_IS_MINER_FILES_PEER_LISTENER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object),
TRACKER_TYPE_MINER_FILES_PEER_LISTENER))
+#define TRACKER_IS_MINER_FILES_PEER_LISTENER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),
TRACKER_TYPE_MINER_FILES_PEER_LISTENER))
+#define TRACKER_MINER_FILES_PEER_LISTENER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj),
TRACKER_TYPE_MINER_FILES_PEER_LISTENER, TrackerMinerFilesPeerListenerClass))
+
+typedef struct _TrackerMinerFilesPeerListener TrackerMinerFilesPeerListener;
+typedef struct _TrackerMinerFilesPeerListenerClass TrackerMinerFilesPeerListenerClass;
+
+struct _TrackerMinerFilesPeerListener {
+ GObject parent_instance;
+};
+
+struct _TrackerMinerFilesPeerListenerClass {
+ GObjectClass parent_class;
+};
+
+GType tracker_miner_files_peer_listener_get_type (void) G_GNUC_CONST;
+
+TrackerMinerFilesPeerListener *
+ tracker_miner_files_peer_listener_new (GDBusConnection *connection);
+
+void tracker_miner_files_peer_listener_add_watch (TrackerMinerFilesPeerListener *listener,
+ const gchar *dbus_name,
+ GFile *file);
+void tracker_miner_files_peer_listener_remove_watch (TrackerMinerFilesPeerListener *listener,
+ const gchar *dbus_name,
+ GFile *file);
+
+void tracker_miner_files_peer_listener_remove_dbus_name (TrackerMinerFilesPeerListener *listener,
+ const gchar *dbus_name);
+void tracker_miner_files_peer_listener_remove_file (TrackerMinerFilesPeerListener *listener,
+ GFile *file);
+gboolean tracker_miner_files_peer_listener_is_file_watched (TrackerMinerFilesPeerListener *listener,
+ GFile *file);
+
+#endif /* __TRACKER_MINER_FILES_PEER_LISTENER_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
