/****************************************************************************** * Copyright (C) 2015 Felix Rohrbach * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser 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 */ #include "room.h" #include #include #include #include // for efficient string concats (operator%) #include #include "connection.h" #include "state.h" #include "user.h" #include "events/roommessageevent.h" #include "events/roomnameevent.h" #include "events/roomaliasesevent.h" #include "events/roomcanonicalaliasevent.h" #include "events/roomtopicevent.h" #include "events/roommemberevent.h" #include "events/typingevent.h" #include "events/receiptevent.h" #include "jobs/roommessagesjob.h" using namespace QMatrixClient; class Room::Private { public: /** Map of user names to users. User names potentially duplicate, hence a multi-hashmap. */ typedef QMultiHash members_map_t; Private(Connection* c, const QString& id_) : q(nullptr), connection(c), id(id_), joinState(JoinState::Join) , unreadMessages(false), highlightCount(0), notificationCount(0) , roomMessagesJob(nullptr) { } Room* q; // This updates the room displayname field (which is the way a room // should be shown in the room list) It should be called whenever the // list of members or the room name (m.room.name) or canonical alias change. void updateDisplayname(); Connection* connection; Timeline messageEvents; QString id; QStringList aliases; QString canonicalAlias; QString name; QString displayname; QString topic; JoinState joinState; bool unreadMessages; int highlightCount; int notificationCount; members_map_t membersMap; QList usersTyping; QList membersLeft; QHash lastReadEvent; QString prevBatch; RoomMessagesJob* roomMessagesJob; // Convenience methods to work with the membersMap and usersLeft. // addMember() and removeMember() emit respective Room:: signals // after a succesful operation. //void inviteUser(User* u); // We might get it at some point in time. void addMember(User* u); bool hasMember(User* u) const; // You can't identify a single user by displayname, only by id User* member(QString id) const; void renameMember(User* u, QString oldName); void removeMember(User* u); void getPreviousContent(); bool isEventNotable(const Event* e) const; private: QString calculateDisplayname() const; QString roomNameFromMemberNames(const QList& userlist) const; void insertMemberIntoMap(User* u); void removeMemberFromMap(QString username, User* u); }; Room::Room(Connection* connection, QString id) : QObject(connection), d(new Private(connection, id)) { // See "Accessing the Public Class" section in // https://marcmutz.wordpress.com/translated-articles/pimp-my-pimpl-%E2%80%94-reloaded/ d->q = this; qDebug() << "New Room:" << id; //connection->getMembers(this); // I don't think we need this anymore in r0.0.1 } Room::~Room() { delete d; } QString Room::id() const { return d->id; } const Room::Timeline& Room::messageEvents() const { return d->messageEvents; } QString Room::name() const { return d->name; } QStringList Room::aliases() const { return d->aliases; } QString Room::canonicalAlias() const { return d->canonicalAlias; } QString Room::displayName() const { return d->displayname; } QString Room::topic() const { return d->topic; } JoinState Room::joinState() const { return d->joinState; } void Room::setJoinState(JoinState state) { JoinState oldState = d->joinState; if( state == oldState ) return; d->joinState = state; emit joinStateChanged(oldState, state); } void Room::setLastReadEvent(User* user, QString eventId) { d->lastReadEvent.insert(user, eventId); emit lastReadEventChanged(user); if (user == d->connection->user()) emit readMarkerPromoted(); } Room::Timeline::const_iterator Room::promoteReadMarker(User* u, QString eventId) { QString prevLastReadId = lastReadEvent(u); int stillUnreadMessagesCount = 0; auto it = d->messageEvents.end(); Event* targetEvent = nullptr; // Older Qt doesn't provide rbegin()/rend() for Qt containers while (it != d->messageEvents.begin()) { --it; // Check that the new read event is not before the previously set - only // allow the read marker to move down the timeline, not up. if (prevLastReadId == (*it)->id()) break; // Found the message to mark as read; if there are messages from // that user right below this one, automatically promote the marker // to them instead of this one; still return this one to save // markMessagesAsRead() from going through local messages over again. if (eventId == (*it)->id()) { setLastReadEvent(u, (targetEvent ? targetEvent : *it)->id()); break; } // If we are on a message from that user (or a series thereof), // remember it (or the end of the sequence) so that we could use it // in case when the event to promote the marker to is immediately // above the ones from that user. if ((*it)->senderId() == u->id()) { if (!targetEvent) targetEvent = *it; } else targetEvent = nullptr; // Detect events "notable" for the local user so that we can properly // set unreadMessages if (u == connection()->user()) stillUnreadMessagesCount += d->isEventNotable(*it); } if( u == connection()->user() ) { if (d->unreadMessages && stillUnreadMessagesCount == 0) { d->unreadMessages = false; qDebug() << "Room" << displayName() << ": no more unread messages"; emit unreadMessagesChanged(this); } if (stillUnreadMessagesCount > 0) qDebug() << "Room" << displayName() << ": still" << stillUnreadMessagesCount << "unread message(s)"; } return it; } void Room::markMessagesAsRead(QString uptoEventId) { if (d->messageEvents.empty()) return; User* localUser = connection()->user(); QString prevLastReadId = lastReadEvent(localUser); auto last = promoteReadMarker(localUser, uptoEventId); // We shouldn't send read receipts for messages from the local user - so // shift back (if necessary) to the nearest message not from the local user // or the so far last read message, whichever comes first. for (; (*last)->id() != prevLastReadId; --last) { if ((*last)->senderId() != connection()->userId()) { d->connection->postReceipt(this, *last); break; } if (last == messageEvents().begin()) break; } } void Room::markMessagesAsRead() { if (!messageEvents().empty()) markMessagesAsRead(messageEvents().back()->id()); } bool Room::hasUnreadMessages() { return d->unreadMessages; } QString Room::lastReadEvent(User* user) const { return d->lastReadEvent.value(user); } QString Room::readMarkerEventId() const { return lastReadEvent(d->connection->user()); } int Room::notificationCount() const { return d->notificationCount; } void Room::resetNotificationCount() { if( d->notificationCount == 0 ) return; d->notificationCount = 0; emit notificationCountChanged(this); } int Room::highlightCount() const { return d->highlightCount; } void Room::resetHighlightCount() { if( d->highlightCount == 0 ) return; d->highlightCount = 0; emit highlightCountChanged(this); } QList< User* > Room::usersTyping() const { return d->usersTyping; } QList< User* > Room::membersLeft() const { return d->membersLeft; } QList< User* > Room::users() const { return d->membersMap.values(); } void Room::Private::insertMemberIntoMap(User *u) { QList namesakes = membersMap.values(u->name()); membersMap.insert(u->name(), u); // If there is exactly one namesake of the added user, signal member renaming // for that other one because the two should be disambiguated now. if (namesakes.size() == 1) emit q->memberRenamed(namesakes[0]); updateDisplayname(); } void Room::Private::removeMemberFromMap(QString username, User* u) { membersMap.remove(username, u); // If there was one namesake besides the removed user, signal member renaming // for it because it doesn't need to be disambiguated anymore. // TODO: Think about left users. QList formerNamesakes = membersMap.values(username); if (formerNamesakes.size() == 1) emit q->memberRenamed(formerNamesakes[0]); updateDisplayname(); } void Room::Private::addMember(User *u) { if (!hasMember(u)) { insertMemberIntoMap(u); connect(u, &User::nameChanged, q, &Room::userRenamed); emit q->userAdded(u); } } bool Room::Private::hasMember(User* u) const { return membersMap.values(u->name()).contains(u); } User* Room::Private::member(QString id) const { User* u = connection->user(id); return hasMember(u) ? u : nullptr; } void Room::Private::renameMember(User* u, QString oldName) { if (hasMember(u)) { qWarning() << "Room::Private::renameMember(): the user " << u->name() << "is already known in the room under a new name."; return; } if (membersMap.values(oldName).contains(u)) { removeMemberFromMap(oldName, u); insertMemberIntoMap(u); emit q->memberRenamed(u); updateDisplayname(); } } void Room::Private::removeMember(User* u) { if (hasMember(u)) { if ( !membersLeft.contains(u) ) membersLeft.append(u); removeMemberFromMap(u->name(), u); emit q->userRemoved(u); } } void Room::userRenamed(User* user, QString oldName) { d->renameMember(user, oldName); } QString Room::roomMembername(User *u) const { // See the CS spec, section 11.2.2.3 QString username = u->name(); if (username.isEmpty()) return u->id(); // Get the list of users with the same display name. Most likely, // there'll be one, but there's a chance there are more. auto namesakes = d->membersMap.values(username); if (namesakes.size() == 1) return username; // We expect a user to be a member of the room - but technically it is // possible to invoke roomMemberName() even for non-members. In such case // we return the name _with_ id, to stay on a safe side. if ( !namesakes.contains(u) ) { qWarning() << "Room::roomMemberName(): user" << u->id() << "is not a member of the room" << id(); } // In case of more than one namesake, disambiguate with user id. return username % " (" % u->id() % ")"; } QString Room::roomMembername(QString userId) const { return roomMembername(connection()->user(userId)); } void Room::updateData(SyncRoomData& data) { if( d->prevBatch.isEmpty() ) d->prevBatch = data.timelinePrevBatch; setJoinState(data.joinState); processStateEvents(data.state); // State changes can arrive in a timeline event; so check those. processStateEvents(data.timeline); addNewMessageEvents(data.timeline.release()); for( Event* ephemeralEvent: data.ephemeral ) { processEphemeralEvent(ephemeralEvent); } if( data.highlightCount != d->highlightCount ) { d->highlightCount = data.highlightCount; emit highlightCountChanged(this); } if( data.notificationCount != d->notificationCount ) { d->notificationCount = data.notificationCount; emit notificationCountChanged(this); } } void Room::getPreviousContent() { d->getPreviousContent(); } void Room::Private::getPreviousContent() { if( !roomMessagesJob ) { roomMessagesJob = connection->getMessages(q, prevBatch); connect( roomMessagesJob, &RoomMessagesJob::result, [=]() { if( !roomMessagesJob->error() ) { q->addHistoricalMessageEvents(roomMessagesJob->events()); prevBatch = roomMessagesJob->end(); } roomMessagesJob = nullptr; }); } } Connection* Room::connection() const { return d->connection; } void Room::addNewMessageEvents(const Events& events) { if (events.empty()) return; emit aboutToAddNewMessages(events); doAddNewMessageEvents(events); emit addedMessages(); } bool Room::Private::isEventNotable(const Event* e) const { return e->senderId() != connection->userId() && e->type() == EventType::RoomMessage; } void Room::doAddNewMessageEvents(const Events& events) { d->messageEvents.reserve(d->messageEvents.size() + events.size()); Timeline::size_type newUnreadMessages = 0; // The first message in the batch defines whose read marker we can // automatically promote any further. Others will need explicit read receipts // from the server (or, for the local user, markMessagesAsRead() invocation) // to promote their read markers over the new message events. User* firstWriter = connection()->user(events.front()->senderId()); bool canAutoPromote = d->messageEvents.empty() || lastReadEvent(firstWriter) == d->messageEvents.back()->id(); Event* firstWriterSeriesEnd = canAutoPromote ? events.front() : nullptr; for (auto e: events) { d->messageEvents.push_back(e); newUnreadMessages += d->isEventNotable(e); if (firstWriterSeriesEnd) { if (e->senderId() != firstWriter->id()) firstWriterSeriesEnd = e; else { setLastReadEvent(firstWriter, firstWriterSeriesEnd->id()); firstWriterSeriesEnd = nullptr; } } } if( !d->unreadMessages && newUnreadMessages > 0) { d->unreadMessages = true; emit unreadMessagesChanged(this); qDebug() << "Room" << displayName() << ": unread messages"; } } void Room::addHistoricalMessageEvents(const Events& events) { if (events.empty()) return; emit aboutToAddHistoricalMessages(events); doAddHistoricalMessageEvents(events); emit addedMessages(); } void Room::doAddHistoricalMessageEvents(const Events& events) { // Historical messages arrive in newest-to-oldest order d->messageEvents.reserve(d->messageEvents.size() + events.size()); std::copy(events.begin(), events.end(), std::front_inserter(d->messageEvents)); } void Room::processStateEvents(const Events& events) { for (auto event: events) { if( event->type() == EventType::RoomName ) { RoomNameEvent* nameEvent = static_cast(event); d->name = nameEvent->name(); qDebug() << "room name:" << d->name; d->updateDisplayname(); emit namesChanged(this); } if( event->type() == EventType::RoomAliases ) { RoomAliasesEvent* aliasesEvent = static_cast(event); d->aliases = aliasesEvent->aliases(); qDebug() << "room aliases:" << d->aliases; // No displayname update - aliases are not used to render a displayname emit namesChanged(this); } if( event->type() == EventType::RoomCanonicalAlias ) { RoomCanonicalAliasEvent* aliasEvent = static_cast(event); d->canonicalAlias = aliasEvent->alias(); qDebug() << "room canonical alias:" << d->canonicalAlias; d->updateDisplayname(); emit namesChanged(this); } if( event->type() == EventType::RoomTopic ) { RoomTopicEvent* topicEvent = static_cast(event); d->topic = topicEvent->topic(); emit topicChanged(); } if( event->type() == EventType::RoomMember ) { RoomMemberEvent* memberEvent = static_cast(event); // Can't use d->member() below because the user may be not a member (yet) User* u = d->connection->user(memberEvent->userId()); u->processEvent(event); if( memberEvent->membership() == MembershipType::Join ) { d->addMember(u); } else if( memberEvent->membership() == MembershipType::Leave ) { d->removeMember(u); } } } } void Room::processEphemeralEvent(Event* event) { if( event->type() == EventType::Typing ) { TypingEvent* typingEvent = static_cast(event); d->usersTyping.clear(); for( const QString& userId: typingEvent->users() ) { if (auto m = d->member(userId)) d->usersTyping.append(m); } emit typingChanged(); } if( event->type() == EventType::Receipt ) { auto receiptEvent = static_cast(event); for( QString eventId: receiptEvent->events() ) { const auto receipts = receiptEvent->receiptsForEvent(eventId); for( const Receipt& r: receipts ) if (auto m = d->member(r.userId)) promoteReadMarker(m, eventId); } } } QString Room::Private::roomNameFromMemberNames(const QList &userlist) const { // This is part 3(i,ii,iii) in the room displayname algorithm described // in the CS spec (see also Room::Private::updateDisplayname() ). // The spec requires to sort users lexicographically by state_key (user id) // and use disambiguated display names of two topmost users excluding // the current one to render the name of the room. // std::array is the leanest C++ container std::array first_two = { {nullptr, nullptr} }; std::partial_sort_copy( userlist.begin(), userlist.end(), first_two.begin(), first_two.end(), [this](const User* u1, const User* u2) { // Filter out the "me" user so that it never hits the room name return u2 == connection->user() || (u1 != connection->user() && u1->id() < u2->id()); } ); // i. One-on-one chat. first_two[1] == connection->user() in this case. if (userlist.size() == 2) return q->roomMembername(first_two[0]); // ii. Two users besides the current one. if (userlist.size() == 3) return tr("%1 and %2") .arg(q->roomMembername(first_two[0])) .arg(q->roomMembername(first_two[1])); // iii. More users. if (userlist.size() > 3) return tr("%1 and %L2 others") .arg(q->roomMembername(first_two[0])) .arg(userlist.size() - 3); // userlist.size() < 2 - apparently, there's only current user in the room return QString(); } QString Room::Private::calculateDisplayname() const { // CS spec, section 11.2.2.5 Calculating the display name for a room // Numbers below refer to respective parts in the spec. // 1. Name (from m.room.name) if (!name.isEmpty()) { // The below two lines extend the spec. They take care of the case // when there are two rooms with the same name. // The format is unwittingly borrowed from the email address format. if (!canonicalAlias.isEmpty()) return name % " <" % canonicalAlias % ">"; return name; } // 2. Canonical alias if (!canonicalAlias.isEmpty()) return canonicalAlias; // 3. Room members QString topMemberNames = roomNameFromMemberNames(membersMap.values()); if (!topMemberNames.isEmpty()) return topMemberNames; // 4. Users that previously left the room topMemberNames = roomNameFromMemberNames(membersLeft); if (!topMemberNames.isEmpty()) return tr("Empty room (was: %1)").arg(topMemberNames); // 5. Fail miserably return tr("Empty room (%1)").arg(id); // Using m.room.aliases is explicitly discouraged by the spec //if (!aliases.empty() && !aliases.at(0).isEmpty()) // displayname = aliases.at(0); } void Room::Private::updateDisplayname() { const QString old_name = displayname; displayname = calculateDisplayname(); if (old_name != displayname) emit q->displaynameChanged(q); } MemberSorter Room::memberSorter() const { return MemberSorter(this); } bool MemberSorter::operator()(User *u1, User *u2) const { auto n1 = room->roomMembername(u1); auto n2 = room->roomMembername(u2); if (n1[0] == '@') n1.remove(0, 1); if (n2[0] == '@') n2.remove(0, 1); return n1 < n2; }