[gnome-documents/wip/carlosg/tracker3: 19/22] changeMonitor: Rewrite to use TrackerNotifier

[Carlos Garnacho <carlosg src gnome org>]

commit e4b48b1227b7cdff28abfc77dfafe6a83e286aa9
Author: Carlos Garnacho <carlosg gnome org>
Date:   Sun Jan 17 17:02:04 2021 +0100

    changeMonitor: Rewrite to use TrackerNotifier
    
    The GraphUpdated DBus signal became superseded by TrackerNotifier
    in 2.x, and completely removed on 3.x. Use TrackerNotifier here
    for event tracking.

 src/changeMonitor.js | 182 ++++++++++-----------------------------------------
 1 file changed, 36 insertions(+), 146 deletions(-)
---
diff --git a/src/changeMonitor.js b/src/changeMonitor.js
index 5308b042..0172cd65 100644
--- a/src/changeMonitor.js
+++ b/src/changeMonitor.js
@@ -20,167 +20,57 @@
  */
 
 const Gio = imports.gi.Gio;
+const Lang = imports.lang;
 const Mainloop = imports.mainloop;
 const Signals = imports.signals;
+const Tracker = imports.gi.Tracker;
 
 const Application = imports.application;
 
-const TrackerResourcesServiceIface = '<node> \
-<interface name="org.freedesktop.Tracker1.Resources"> \
-    <signal name="GraphUpdated"> \
-        <arg name="className" type="s" /> \
-        <arg name="deleteEvents" type="a(iiii)" /> \
-        <arg name="insertEvents" type="a(iiii)" /> \
-    </signal> \
-</interface> \
-</node>';
-
-var TrackerResourcesServiceProxy = Gio.DBusProxy.makeProxyWrapper(TrackerResourcesServiceIface);
-function TrackerResourcesService() {
-    return new TrackerResourcesServiceProxy(Gio.DBus.session,
-                                            'org.freedesktop.Tracker1',
-                                            '/org/freedesktop/Tracker1/Resources');
-}
-
 var ChangeEventType = {
     CHANGED: 0,
     CREATED: 1,
     DELETED: 2
 };
 
-const _RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";;
-
-const ChangeEvent = class ChangeEvent {
-    constructor(urnId, predicateId, isDelete) {
-        this.urnId = urnId;
-        this.predicateId = predicateId;
-
-        if (isDelete)
-            this.type = ChangeEventType.DELETED;
-        else
-            this.type = ChangeEventType.CREATED;
-    }
+const ChangeEvent = new Lang.Class({
+    Name: 'ChangeEvent',
 
-    setResolvedValues(urn, predicate) {
+    _init: function(type, urn) {
         this.urn = urn;
-        this.predicate = predicate;
 
-        if (predicate != _RDF_TYPE)
+        if (type == Tracker.NotifierEventType.CREATE)
+            this.type = ChangeEventType.CREATED;
+        else if (type == Tracker.NotifierEventType.DELETE)
+            this.type = ChangeEventType.DELETED;
+        else if (type == Tracker.NotifierEventType.UPDATE)
             this.type = ChangeEventType.CHANGED;
     }
-
-    merge(event) {
-        // deletions or creations override the current type
-        if (event.type == ChangeEventType.DELETED ||
-            event.type == ChangeEventType.CREATED) {
-            this.type = event.type;
-        }
-    }
-}
-
-const CHANGE_MONITOR_TIMEOUT = 500; // msecs
-const CHANGE_MONITOR_MAX_ITEMS = 500; // items
-
-var TrackerChangeMonitor = class TrackerChangeMonitor {
-    constructor() {
-        this._pendingChanges = {};
-        this._unresolvedIds = {};
-
-        this._pendingEvents = [];
-        this._pendingEventsId = 0;
-
-        this._resourceService = new TrackerResourcesService();
-        this._resourceService.connectSignal('GraphUpdated', this._onGraphUpdated.bind(this));
-    }
-
-    _onGraphUpdated(proxy, senderName, [className, deleteEvents, insertEvents]) {
-        deleteEvents.forEach((event) => {
-            this._addPendingEvent(event, true);
-        });
-
-        insertEvents.forEach((event) => {
-            this._addPendingEvent(event, false);
-        });
-    }
-
-    _addPendingEvent(event, isDelete) {
-        if (this._pendingEventsId != 0)
-            Mainloop.source_remove(this._pendingEventsId);
-
-        this._unresolvedIds[event[1]] = event[1];
-        this._unresolvedIds[event[2]] = event[2];
-        this._pendingEvents.push(new ChangeEvent(event[1], event[2], isDelete));
-
-        if (this._pendingEvents.length >= CHANGE_MONITOR_MAX_ITEMS)
-            this._processEvents();
-        else
-            this._pendingEventsId =
-                Mainloop.timeout_add(CHANGE_MONITOR_TIMEOUT, this._processEvents.bind(this));
-    }
-
-    _processEvents() {
-        let events = this._pendingEvents;
-        let idTable = this._unresolvedIds;
-
-        this._pendingEventsId = 0;
-        this._pendingEvents = [];
-        this._unresolvedIds = {};
-
-        let sparql = 'SELECT';
-        Object.keys(idTable).forEach((unresolvedId) => {
-            sparql += (' tracker:uri(%d)').format(unresolvedId);
-        });
-        sparql += ' {}';
-
-        // resolve all the unresolved IDs we got so far
-        Application.connectionQueue.add(sparql, null, (object, res) => {
-            let cursor = object.query_finish(res);
-
-            cursor.next_async(null, (object, res) => {
-                let valid = false;
-                try {
-                    valid = cursor.next_finish(res);
-                } catch(e) {
-                    logError(e, 'Unable to resolve item URNs for graph changes');
-                }
-
-                if (valid) {
-                    let idx = 0;
-                    Object.keys(idTable).forEach((unresolvedId) => {
-                        idTable[unresolvedId] = cursor.get_string(idx)[0];
-                        idx++;
-                    });
-
-                    this._sendEvents(events, idTable);
-                }
-
-                cursor.close();
-            });
-        });
-
-        return false;
-    }
-
-    _addEvent(event) {
-        let urn = event.urn;
-        let oldEvent = this._pendingChanges[urn];
-
-        if (oldEvent != null) {
-            oldEvent.merge(event);
-            this._pendingChanges[urn] = oldEvent;
-        } else {
-            this._pendingChanges[urn] = event;
-        }
-    }
-
-    _sendEvents(events, idTable) {
-        events.forEach((event) => {
-            event.setResolvedValues(idTable[event.urnId], idTable[event.predicateId]);
-            this._addEvent(event);
-        });
-
-        this.emit('changes-pending', this._pendingChanges);
-        this._pendingChanges = {};
+});
+
+var TrackerChangeMonitor = new Lang.Class({
+    Name: 'TrackerChangeMonitor',
+
+    _init: function() {
+        this._notifier = Application.connection.create_notifier();
+        this._notifier.signal_subscribe(Gio.DBus.session,
+                                        'org.freedesktop.Tracker3.Miner.Files',
+                                        null,
+                                        'http://tracker.api.gnome.org/ontology/v3/tracker#Documents');
+        this._notifier.connect('events', Lang.bind(this, this._onNotifierEvents));
+    },
+
+    _onNotifierEvents: function(notifier, service, graph, events) {
+        let pendingChanges = {};
+
+        events.forEach(Lang.bind(this,
+            function(event) {
+                let urn = event.get_urn();
+                let changeEvent = new ChangeEvent(event.get_event_type(), urn);
+                pendingChanges[urn] = changeEvent;
+            }));
+
+        this.emit('changes-pending', pendingChanges);
     }
-}
+});
 Signals.addSignalMethods(TrackerChangeMonitor.prototype);