Parse m.presence events from /events

lib/client.js

@@ -108,6 +108,16 @@ MatrixClient.prototype.getRooms = function() {
     return this.store.getRooms();
 };
 
+/**
+ * Retrieve a user.
+ * @param {string} userId The user ID to retrieve.
+ * @return {?User} A user or null if there is no data store or the user does
+ * not exist.
+ */
+MatrixClient.prototype.getUser = function(userId) {
+    return this.store.getUser(userId);
+};
+
 // Room operations
 // ===============
 
@@ -1292,6 +1302,17 @@ function _pollForEvents(client) {
                     }
                     roomIdToEvents[roomId].push(events[i]);
                 }
+                else if (events[i].getType() === "m.presence") {
+                    var usr = self.store.getUser(events[i].getContent().user_id);
+                    if (usr) {
+                        usr.setPresenceEvent(events[i]);
+                    }
+                    else {
+                        usr = createNewUser(self, events[i].getContent().user_id);
+                        usr.setPresenceEvent(events[i]);
+                        self.store.storeUser(usr);
+                    }
+                }
             }
             // add events to room
             var roomIds = utils.keys(roomIdToEvents);

spec/integ/matrix-client-syncing.spec.js

@@ -64,6 +64,53 @@ describe("MatrixClient syncing", function() {
         });
     });
 
+    describe("users", function() {
+        var userA = "@alice:bar";
+        var userB = "@bob:bar";
+        var userC = "@claire:bar";
+        var initialSync = {
+            end: "s_5_3",
+            presence: [
+                utils.mkPresence({
+                    user: userA, presence: "online"
+                }),
+                utils.mkPresence({
+                    user: userB, presence: "unavailable"
+                })
+            ],
+            rooms: []
+        };
+        var eventData = {
+            start: "s_5_3",
+            end: "e_6_7",
+            chunk: [
+                // existing user change
+                utils.mkPresence({
+                    user: userA, presence: "offline"
+                }),
+                // new user C
+                utils.mkPresence({
+                    user: userC, presence: "online"
+                })
+            ]
+        };
+
+        it("should create users for presence events from /initialSync and /events",
+        function(done) {
+            httpBackend.when("GET", "/initialSync").respond(200, initialSync);
+            httpBackend.when("GET", "/events").respond(200, eventData);
+
+            client.startClient();
+
+            httpBackend.flush().done(function() {
+                expect(client.getUser(userA).presence).toEqual("offline");
+                expect(client.getUser(userB).presence).toEqual("unavailable");
+                expect(client.getUser(userC).presence).toEqual("online");
+                done();
+            });
+        });
+    });
+
     describe("room state", function() {
         var roomOne = "!foo:localhost";
         var roomTwo = "!bar:localhost";

spec/test-utils.js

@@ -76,6 +76,29 @@ module.exports.mkEvent = function(opts) {
     return opts.event ? new MatrixEvent(event) : event;
 };
 
+/**
+ * Create an m.presence event.
+ * @param {Object} opts Values for the presence.
+ * @return {Object|MatrixEvent} The event
+ */
+module.exports.mkPresence = function(opts) {
+    if (!opts.user) {
+        throw new Error("Missing user");
+    }
+    var event = {
+        event_id: "$" + Math.random() + "-" + Math.random(),
+        type: "m.presence",
+        content: {
+            user_id: opts.user,
+            avatar_url: opts.url,
+            displayname: opts.name,
+            last_active_ago: opts.ago,
+            presence: opts.presence || "offline"
+        }
+    };
+    return opts.event ? new MatrixEvent(event) : event;
+};
+
 /**
  * Create an m.room.member event.
  * @param {Object} opts Values for the membership.