Merge branch 'master' into kitsune-gtad

35 files changed, 1595 insertions, 517 deletions

diff --git a/.travis.yml b/.travis.yml
index 79d7720e..9b690d10 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,7 +14,7 @@ matrix:
   include:
   - os: linux
     compiler: gcc
-    env: [ ENV_EVAL="CC=gcc-5 && CXX=g++-5" ]
+    env: [ 'ENV_EVAL="CC=gcc-5 && CXX=g++-5"' ]
   - os: linux
     compiler: clang
   - os: osx
@@ -22,7 +22,7 @@ matrix:
 
 before_install:
 - eval "${ENV_EVAL}"
-- if [ "$TRAVIS_OS_NAME" = "linux" ]; then . /opt/qt56/bin/qt56-env.sh; fi
+- if [ "$TRAVIS_OS_NAME" = "linux" ]; then VALGRIND="valgrind $VALGRIND_OPTIONS"; . /opt/qt56/bin/qt56-env.sh; fi
 
 install:
 - git clone https://github.com/QMatrixClient/matrix-doc.git
@@ -40,8 +40,9 @@ before_script:
 script:
 - cmake --build . --target all
 - cd ..
-- qmake qmc-example.pro "CONFIG += debug" "QMAKE_CC = $CC" "QMAKE_CXX = $CXX" && make all
-- if [ "$TRAVIS_OS_NAME" = "linux" ]; then valgrind --tool=memcheck --leak-check=yes --show-reachable=yes ./qmc-example "$QMC_TEST_USER" "$QMC_TEST_PWD" '#qmc-test:matrix.org'; fi
+- qmake qmc-example.pro "CONFIG += debug" "CONFIG -= app_bundle" "QMAKE_CC = $CC" "QMAKE_CXX = $CXX"
+- make all
+- if [ "$QMC_TEST_USER" != "" ]; then $VALGRIND ./qmc-example "$QMC_TEST_USER" "$QMC_TEST_PWD" qmc-example-travis '#qmc-test:matrix.org' "Travis CI job $TRAVIS_JOB_NUMBER"; fi
 
 notifications:
   webhooks:
diff --git a/.valgrind.qmc-example.supp b/.valgrind.qmc-example.supp
new file mode 100644
index 00000000..cb4e1e74
--- /dev/null
+++ b/.valgrind.qmc-example.supp
@@ -0,0 +1,171 @@
+{
+   libc_dirty_free_on_exit
+   Memcheck:Free
+   fun:free
+   fun:__libc_freeres
+   fun:_vgnU_freeres
+   fun:__run_exit_handlers
+   fun:exit
+}
+
+{
+   sendPostedEvents1
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   fun:_ZN15QtSharedPointer20ExternalRefCountData9getAndRefEPK7QObject
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+}
+
+{
+   sendPostedEvents3
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   ...
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   fun:_ZN7QObject5eventEP6QEvent
+   fun:_ZN16QCoreApplication6notifyEP7QObjectP6QEvent
+   fun:_ZN16QCoreApplication15notifyInternal2EP7QObjectP6QEvent
+   fun:_ZN23QCoreApplicationPrivate16sendPostedEventsEP7QObjectiP11QThreadData
+   obj:/opt/qt56/lib/libQt5Core.so.5.6.3
+}
+
+{
+   QAuthenticator
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:_ZN14QAuthenticator6detachEv
+}
+
+{
+   sendPostedEvents5
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:realloc
+   fun:_ZN9QListData12realloc_growEi
+   fun:_ZN9QListData7prependEv
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   fun:_ZN7QObject5eventEP6QEvent
+   fun:_ZN16QCoreApplication6notifyEP7QObjectP6QEvent
+   fun:_ZN16QCoreApplication15notifyInternal2EP7QObjectP6QEvent
+   fun:_ZN23QCoreApplicationPrivate16sendPostedEventsEP7QObjectiP11QThreadData
+}
+
+{
+   QObject_connect
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   obj:/opt/qt56/lib/libQt5Core.so.5.6.3
+   fun:_ZN7QObject7connectEPKS_PKcS1_S3_N2Qt14ConnectionTypeE
+}
+
+{
+   QNetworkProxy
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   fun:_ZN13QNetworkProxyC1ENS_9ProxyTypeERK7QStringtS3_S3_
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+}
+
+{
+   QTimer
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   fun:_ZN7QObjectC1EPS_
+   fun:_ZN6QTimerC1EP7QObject
+}
+
+{
+   QSslConfiguration
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   ...
+   fun:_ZN17QSslConfigurationC1Ev
+}
+
+{
+   sendPostedEvents6
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+   fun:_ZN7QObject5eventEP6QEvent
+   fun:_ZN16QCoreApplication6notifyEP7QObjectP6QEvent
+   fun:_ZN16QCoreApplication15notifyInternal2EP7QObjectP6QEvent
+   fun:_ZN23QCoreApplicationPrivate16sendPostedEventsEP7QObjectiP11QThreadData
+}
+
+{
+    QMetaObject_activate_in_QtNetwork
+    Memcheck:Leak
+    match-leak-kinds: possible
+    fun:_Znwm
+    ...
+    obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+    fun:_ZN11QMetaObject8activateEP7QObjectiiPPv
+}
+
+{
+   QMapDatabase_from_QtNetwork
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   fun:_ZN12QMapDataBase10createDataEv
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+}
+
+{
+   QThread
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:_ZN7QThread5startENS_8PriorityE
+}
+
+{
+   libcrypto_ASN1
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   ...
+   fun:ASN1_item_ex_d2i
+}
+
+{
+   QObject_from_QtNetwork
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   fun:_ZN7QObjectC1EPS_
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+}
+
+{
+   array_new_from_QtNetwork
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znam
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+}
+
+{
+   malloc_from_libcrypto
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:malloc
+   fun:CRYPTO_malloc
+   ...
+   obj:/lib/x86_64-linux-gnu/libcrypto.so.1.0.0
+   ...
+   obj:/opt/qt56/lib/libQt5Network.so.5.6.3
+}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 13afab21..5e5b191e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,33 +49,33 @@ message( STATUS )
 
 # Set up source files
 set(libqmatrixclient_SRCS
-   networkaccessmanager.cpp
-   connectiondata.cpp
-   connection.cpp
-   logging.cpp
-   room.cpp
-   user.cpp
-   avatar.cpp
-   settings.cpp
-   networksettings.cpp
-   events/event.cpp
-   events/eventcontent.cpp
-   events/roommessageevent.cpp
-   events/roommemberevent.cpp
-   events/roomavatarevent.cpp
-   events/typingevent.cpp
-   events/receiptevent.cpp
-   events/tagevent.cpp
-   jobs/requestdata.cpp
-   jobs/basejob.cpp
-   jobs/checkauthmethods.cpp
-   jobs/sendeventjob.cpp
-   jobs/setroomstatejob.cpp
-   jobs/joinroomjob.cpp
-   jobs/roommessagesjob.cpp
-   jobs/syncjob.cpp
-   jobs/mediathumbnailjob.cpp
-   jobs/downloadfilejob.cpp
+    networkaccessmanager.cpp
+    connectiondata.cpp
+    connection.cpp
+    logging.cpp
+    room.cpp
+    user.cpp
+    avatar.cpp
+    settings.cpp
+    networksettings.cpp
+    events/event.cpp
+    events/eventcontent.cpp
+    events/roommessageevent.cpp
+    events/roommemberevent.cpp
+    events/roomavatarevent.cpp
+    events/typingevent.cpp
+    events/receiptevent.cpp
+    events/directchatevent.cpp
+    jobs/requestdata.cpp
+    jobs/basejob.cpp
+    jobs/checkauthmethods.cpp
+    jobs/sendeventjob.cpp
+    jobs/setroomstatejob.cpp
+    jobs/joinroomjob.cpp
+    jobs/roommessagesjob.cpp
+    jobs/syncjob.cpp
+    jobs/mediathumbnailjob.cpp
+    jobs/downloadfilejob.cpp
 )
 
 set(API_DEF_PATH ${MATRIX_DOC_PATH}/api/client-server/)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e67fabed..e576b886 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -108,6 +108,14 @@ We will gladly give credit to anyone who reports a vulnerability so that we can
 
 The code should strive to be DRY (don't repeat yourself), clear, and obviously correct. Some technical debt is inevitable, just don't bankrupt us with it. Refactoring is welcome.
 
+### Library API and doc-comments
+
+Whenever you add a new call to the library API that you expect to be used from client code, you must supply a proper doc-comment along with the call. Doxygen (with backslashes) style is preferred. You can find that some parts of the code still use JavaDoc (with @'s) style; feel free to replace it with Doxygen backslashes if that bothers you.
+
+Calls, data structures and other symbols not intended for use by clients should _not_ be exposed in (public) .h files, unless they are necessary to declare other public symbols. In particular, this involves private members (functions, typedefs, or variables) in public classes; use pimpl idiom to hide implementation details as much as possible.
+
+Note: As of now, all header files of libqmatrixclient are considered public; this may change eventually.
+
 ### Qt-flavoured C++
 
 This is our primary language. We don't have a particular code style _as of yet_ but some rules-of-thumb are below:
@@ -124,7 +132,7 @@ This is our primary language. We don't have a particular code style _as of yet_
 
 ### Automated tests
 
-There's no testing framework as of now; either Catch or QTest or both will be used eventually (PRs welcome, just don't expect a quick merge of one - we'll hunt you down to actually write some tests first :-D ).
+There's no testing framework as of now; either Catch or QTest or both will be used eventually. However, as a stopgap measure, qmc-example is used for end-to-end testing; so please add another private slot and call it from `QMCTest::doTests()` whenever you add new function worth it. PRs to set up a proper testing appliance instead are very welcome (make sure to migrate tests from qmc-example though).
 
 ### Security, privacy, and performance
 
diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
new file mode 100644
index 00000000..64a80350
--- /dev/null
+++ b/ISSUE_TEMPLATE.md
@@ -0,0 +1,39 @@
+<!-- 
+
+This is a bug report template. By following the instructions below and
+filling out the sections with your information, you will help the us to get all
+the necessary data to fix your issue.
+
+You can also preview your report before submitting it. You may remove sections
+that aren't relevant to your particular case.
+
+Text between <!-- and --​> marks will be invisible in the report.
+
+-->
+
+### Description
+
+Describe here the problem that you are experiencing, or the feature you are requesting.
+
+### Steps to reproduce
+
+- For bugs, list the steps
+- that reproduce the bug
+- using hyphens as bullet points
+
+Describe how what happens differs from what you expected.
+
+libqmatrixclient-based clients either have a log file or dump log to the standard output.
+If you can identify any log snippets relevant to your issue, please include
+those here (please be careful to remove any personal or private data):
+
+### Version information
+
+<!-- IMPORTANT: please answer the following questions, to help us narrow down the problem -->
+
+- **The client application**: <!-- the problem might be not with the library but with the client -->
+- **libqmatrixclient version if you know it**: <!-- try to find it basing on the client version -->
+- **Qt version**: <!-- for Linux systems, it's usually installed system-wide; for other OSes,
+as well as Flatpak/AppImage/etc. containerised environments, it's a version used in the container. -->
+- **Install method**: <!-- package manager/Flatpak/archive downloaded (from which site?) -->
+- **Platform**: <!-- Operating system and anything about your platform you think can be relevant -->
diff --git a/README.md b/README.md
index fc9ad5e0..dc6b22ca 100644
--- a/README.md
+++ b/README.md
@@ -63,6 +63,8 @@ This will get you `debug/qmc-example` and `release/qmc-example` console executab
 
 ## Troubleshooting
 
+#### Building fails
+
 If `cmake` fails with...
 ```
 CMake Warning at CMakeLists.txt:11 (find_package):
@@ -85,3 +87,6 @@ where
 ```
 QT_LOGGING_RULES="libqmatrixclient.*.debug=true,libqmatrixclient.jobs.debug=false"
 ```
+
+#### Cache format
+In case of troubles with room state and troubles with caching it may be useful to switch cache format from binary to JSON. To do that, set the following value in your client's configuration file/registry key (you might need to create the libqmatrixclient key for that): `libqmatrixclient/cache_type` to `json`. This will make cache saving and loading work slightly slower but the cache will be in a text JSON file (very long and unindented so prepare a good JSON viewer or text editor with JSON formatting capabilities).
diff --git a/avatar.cpp b/avatar.cpp
index 9664199c..1ff2aae1 100644
--- a/avatar.cpp
+++ b/avatar.cpp
@@ -37,6 +37,8 @@ class Avatar::Private
                    get_callback_t callback) const;
         bool upload(UploadContentJob* job, upload_callback_t callback);
 
+        bool checkUrl(QUrl url) const;
+
         const QIcon _defaultIcon;
         QUrl _url;
 
@@ -44,7 +46,8 @@ class Avatar::Private
         mutable QImage _originalImage;
         mutable std::vector<QPair<QSize, QImage>> _scaledImages;
         mutable QSize _requestedSize;
-        mutable bool _valid = false;
+        mutable bool _bannedUrl = false;
+        mutable bool _fetched = false;
         mutable QPointer<MediaThumbnailJob> _thumbnailRequest = nullptr;
         mutable QPointer<BaseJob> _uploadRequest = nullptr;
         mutable std::vector<get_callback_t> callbacks;
@@ -105,9 +108,9 @@ QImage Avatar::Private::get(Connection* connection, QSize size,
     // is a sure way to trick the below code into constantly getting another
     // image from the server because the existing one is alleged unsatisfactory.
     // This is plain abuse by the client, though; so not critical for now.
-    if( ( !(_valid || _thumbnailRequest)
+    if( ( !(_fetched || _thumbnailRequest)
           || size.width() > _requestedSize.width()
-          || size.height() > _requestedSize.height() ) && _url.isValid() )
+          || size.height() > _requestedSize.height() ) && checkUrl(_url) )
     {
         qCDebug(MAIN) << "Getting avatar from" << _url.toString();
         _requestedSize = size;
@@ -117,7 +120,7 @@ QImage Avatar::Private::get(Connection* connection, QSize size,
         _thumbnailRequest = connection->getThumbnail(_url, size);
         QObject::connect( _thumbnailRequest, &MediaThumbnailJob::success, [this]
         {
-            _valid = true;
+            _fetched = true;
             _originalImage = _thumbnailRequest->scaledThumbnail(_requestedSize);
             _scaledImages.clear();
             for (auto n: callbacks)
@@ -153,6 +156,21 @@ bool Avatar::Private::upload(UploadContentJob* job, upload_callback_t callback)
     return true;
 }
 
+bool Avatar::Private::checkUrl(QUrl url) const
+{
+    if (_bannedUrl || url.isEmpty())
+        return false;
+
+    // FIXME: Make "mxc" a library-wide constant and maybe even make
+    // the URL checker a Connection(?) method.
+    _bannedUrl = !(url.isValid() &&
+            url.scheme() == "mxc" && url.path().count('/') == 1);
+    if (_bannedUrl)
+        qCWarning(MAIN) << "Avatar URL is invalid or not mxc-based:"
+                        << url.toDisplayString();
+    return !_bannedUrl;
+}
+
 QUrl Avatar::url() const { return d->_url; }
 
 bool Avatar::updateUrl(const QUrl& newUrl)
@@ -160,15 +178,8 @@ bool Avatar::updateUrl(const QUrl& newUrl)
     if (newUrl == d->_url)
         return false;
 
-    // FIXME: Make it a library-wide constant and maybe even make the URL checker
-    // a Connection(?) method.
-    if (newUrl.scheme() != "mxc"  || newUrl.path().count('/') != 1)
-    {
-        qCWarning(MAIN) << "Malformed avatar URL:" << newUrl.toDisplayString();
-        return false;
-    }
     d->_url = newUrl;
-    d->_valid = false;
+    d->_fetched = false;
     if (isJobRunning(d->_thumbnailRequest))
         d->_thumbnailRequest->abandon();
     return true;
diff --git a/connection.cpp b/connection.cpp
index 98e534b8..2d7235b9 100644
--- a/connection.cpp
+++ b/connection.cpp
@@ -20,11 +20,14 @@
 #include "connectiondata.h"
 #include "user.h"
 #include "events/event.h"
+#include "events/directchatevent.h"
 #include "room.h"
+#include "settings.h"
 #include "jobs/generated/login.h"
 #include "jobs/generated/logout.h"
 #include "jobs/generated/receipts.h"
 #include "jobs/generated/leaving.h"
+#include "jobs/generated/account-data.h"
 #include "jobs/sendeventjob.h"
 #include "jobs/joinroomjob.h"
 #include "jobs/roommessagesjob.h"
@@ -44,6 +47,8 @@
 
 using namespace QMatrixClient;
 
+using DirectChatsMap = QMultiHash<const User*, QString>;
+
 class Connection::Private
 {
     public:
@@ -63,14 +68,19 @@ class Connection::Private
         QHash<QPair<QString, bool>, Room*> roomMap;
         QVector<QString> roomIdsToForget;
         QMap<QString, User*> userMap;
+        DirectChatsMap directChats;
+        QHash<QString, QVariantHash> accountData;
         QString userId;
 
         SyncJob* syncJob = nullptr;
 
         bool cacheState = true;
+        bool cacheToBinary = SettingsGroup("libqmatrixclient")
+                             .value("cache_type").toString() != "json";
 
         void connectWithToken(const QString& user, const QString& accessToken,
                               const QString& deviceId);
+        void broadcastDirectChatUpdates();
 };
 
 Connection::Connection(const QUrl& server, QObject* parent)
@@ -98,12 +108,13 @@ void Connection::resolveServer(const QString& mxidOrDomain)
     // Try to parse as an FQID; if there's no @ part, assume it's a domain name.
     QRegularExpression parser(
         "^(@.+?:)?" // Optional username (allow everything for compatibility)
-        "((\\[[^]]+\\]|[^:@]+)" // Either IPv6 address or hostname/IPv4 address
-        "(:\\d{1,5})?)$", // Optional port
+        "(\\[[^]]+\\]|[^:@]+)" // Either IPv6 address or hostname/IPv4 address
+        "(:\\d{1,5})?$", // Optional port
         QRegularExpression::UseUnicodePropertiesOption); // Because asian digits
     auto match = parser.match(mxidOrDomain);
 
     QUrl maybeBaseUrl = QUrl::fromUserInput(match.captured(2));
+    maybeBaseUrl.setScheme("https"); // Instead of the Qt-default "http"
     if (!match.hasMatch() || !maybeBaseUrl.isValid())
     {
         emit resolveError(
@@ -112,16 +123,14 @@ void Connection::resolveServer(const QString& mxidOrDomain)
         return;
     }
 
-    maybeBaseUrl.setScheme("https"); // Instead of the Qt-default "http"
-    if (maybeBaseUrl.port() != -1)
-    {
-        setHomeserver(maybeBaseUrl);
-        emit resolved();
-        return;
-    }
+    setHomeserver(maybeBaseUrl);
+    emit resolved();
+    return;
 
+    // FIXME, #178: The below code is incorrect and is no more executed. The
+    // correct server resolution should be done from .well-known/matrix/client
     auto domain = maybeBaseUrl.host();
-    qCDebug(MAIN) << "Resolving server" << domain;
+    qCDebug(MAIN) << "Finding the server" << domain;
     // Check if the Matrix server has a dedicated service record.
     QDnsLookup* dns = new QDnsLookup();
     dns->setType(QDnsLookup::SRV);
@@ -190,8 +199,8 @@ void Connection::Private::connectWithToken(const QString& user,
     userId = user;
     data->setToken(accessToken.toLatin1());
     data->setDeviceId(deviceId);
-    qCDebug(MAIN) << "Using server" << data->baseUrl() << "by user"
-                  << userId << "from device" << deviceId;
+    qCDebug(MAIN) << "Using server" << data->baseUrl().toDisplayString()
+                  << "by user" << userId << "from device" << deviceId;
     emit q->connected();
 
 }
@@ -256,7 +265,7 @@ void Connection::sync(int timeout)
 
 void Connection::onSyncSuccess(SyncData &&data) {
     d->data->setLastEvent(data.nextBatch());
-    for( auto&& roomData: data.takeRoomData() )
+    for (auto&& roomData: data.takeRoomData())
     {
         const auto forgetIdx = d->roomIdsToForget.indexOf(roomData.roomId);
         if (forgetIdx != -1)
@@ -275,9 +284,31 @@ void Connection::onSyncSuccess(SyncData &&data) {
         }
         if ( auto* r = provideRoom(roomData.roomId, roomData.joinState) )
             r->updateData(std::move(roomData));
-        QCoreApplication::instance()->processEvents();
+        QCoreApplication::processEvents();
+    }
+    for (auto&& accountEvent: data.takeAccountData())
+    {
+        if (accountEvent->type() == EventType::DirectChat)
+        {
+            DirectChatsMap newDirectChats;
+            const auto* event = static_cast<DirectChatEvent*>(accountEvent.get());
+            auto usersToDCs = event->usersToDirectChats();
+            for (auto it = usersToDCs.begin(); it != usersToDCs.end(); ++it)
+            {
+                newDirectChats.insert(user(it.key()), it.value());
+                qCDebug(MAIN) << "Marked room" << it.value()
+                              << "as a direct chat with" << it.key();
+            }
+            if (newDirectChats != d->directChats)
+            {
+                d->directChats = newDirectChats;
+                emit directChatsListChanged();
+            }
+            continue;
+        }
+        d->accountData[accountEvent->jsonType()] =
+                accountEvent->contentJson().toVariantHash();
     }
-
 }
 
 void Connection::stopSync()
@@ -403,6 +434,49 @@ CreateRoomJob* Connection::createRoom(RoomVisibility visibility,
     return job;
 }
 
+void Connection::requestDirectChat(const QString& userId)
+{
+    doInDirectChat(userId, [this] (Room* r) { emit directChatAvailable(r); });
+}
+
+void Connection::doInDirectChat(const QString& userId,
+                                std::function<void (Room*)> operation)
+{
+    // There can be more than one DC; find the first valid, and delete invalid
+    // (left/forgotten) ones along the way.
+    for (auto roomId: d->directChats.values(user(userId)))
+    {
+        if (auto r = room(roomId, JoinState::Join))
+        {
+            Q_ASSERT(r->id() == roomId);
+            qCDebug(MAIN) << "Requested direct chat with" << userId
+                          << "is already available as" << r->id();
+            operation(r);
+            return;
+        }
+        if (auto ir = invitation(roomId))
+        {
+            Q_ASSERT(ir->id() == roomId);
+            auto j = joinRoom(ir->id());
+            connect(j, &BaseJob::success, this, [this,roomId,userId,operation] {
+                qCDebug(MAIN) << "Joined the already invited direct chat with"
+                              << userId << "as" << roomId;
+                operation(room(roomId, JoinState::Join));
+            });
+        }
+        qCWarning(MAIN) << "Direct chat with" << userId << "known as room"
+                        << roomId << "is not valid, discarding it";
+        removeFromDirectChats(roomId);
+    }
+
+    auto j = createDirectChat(userId);
+    connect(j, &BaseJob::success, this, [this,j,userId,operation] {
+        qCDebug(MAIN) << "Direct chat with" << userId
+                      << "has been created as" << j->roomId();
+        operation(room(j->roomId(), JoinState::Join));
+    });
+}
+
 CreateRoomJob* Connection::createDirectChat(const QString& userId,
     const QString& topic, const QString& name)
 {
@@ -458,6 +532,29 @@ QUrl Connection::homeserver() const
     return d->data->baseUrl();
 }
 
+Room* Connection::room(const QString& roomId, JoinStates states) const
+{
+    Room* room = d->roomMap.value({roomId, false}, nullptr);
+    if (states.testFlag(JoinState::Join) &&
+            room && room->joinState() == JoinState::Join)
+        return room;
+
+    if (states.testFlag(JoinState::Invite))
+        if (Room* invRoom = invitation(roomId))
+            return invRoom;
+
+    if (states.testFlag(JoinState::Leave) &&
+            room && room->joinState() == JoinState::Leave)
+        return room;
+
+    return nullptr;
+}
+
+Room* Connection::invitation(const QString& roomId) const
+{
+    return d->roomMap.value({roomId, true}, nullptr);
+}
+
 User* Connection::user(const QString& userId)
 {
     if( d->userMap.contains(userId) )
@@ -468,11 +565,14 @@ User* Connection::user(const QString& userId)
     return user;
 }
 
-User *Connection::user()
+const User* Connection::user() const
 {
-    if( d->userId.isEmpty() )
-        return nullptr;
-    return user(d->userId);
+    return d->userId.isEmpty() ? nullptr : d->userMap.value(d->userId, nullptr);
+}
+
+User* Connection::user()
+{
+    return d->userId.isEmpty() ? nullptr : user(d->userId);
 }
 
 QString Connection::userId() const
@@ -535,6 +635,17 @@ QHash<QString, QVector<Room*>> Connection::tagsToRooms() const
     return result;
 }
 
+QStringList Connection::tagNames() const
+{
+    QStringList tags ({FavouriteTag});
+    for (auto* r: d->roomMap)
+        for (const auto& tag: r->tagNames())
+            if (tag != LowPriorityTag && !tags.contains(tag))
+                tags.push_back(tag);
+    tags.push_back(LowPriorityTag);
+    return tags;
+}
+
 QVector<Room*> Connection::roomsWithTag(const QString& tagName) const
 {
     QVector<Room*> rooms;
@@ -543,6 +654,60 @@ QVector<Room*> Connection::roomsWithTag(const QString& tagName) const
     return rooms;
 }
 
+QJsonObject toJson(const DirectChatsMap& directChats)
+{
+    QJsonObject json;
+    for (auto it = directChats.keyBegin(); it != directChats.keyEnd(); ++it)
+        json.insert((*it)->id(), toJson(directChats.values(*it)));
+    return json;
+}
+
+void Connection::Private::broadcastDirectChatUpdates()
+{
+    q->callApi<SetAccountDataJob>(userId, QStringLiteral("m.direct"),
+                                  toJson(directChats));
+    emit q->directChatsListChanged();
+}
+
+void Connection::addToDirectChats(const Room* room, const User* user)
+{
+    Q_ASSERT(room != nullptr && user != nullptr);
+    if (d->directChats.contains(user, room->id()))
+        return;
+    d->directChats.insert(user, room->id());
+    d->broadcastDirectChatUpdates();
+}
+
+void Connection::removeFromDirectChats(const QString& roomId, const User* user)
+{
+    Q_ASSERT(!roomId.isEmpty());
+    if ((user != nullptr && !d->directChats.contains(user, roomId)) ||
+            d->directChats.key(roomId) == nullptr)
+        return;
+    if (user != nullptr)
+        d->directChats.remove(user, roomId);
+    else
+        for (auto it = d->directChats.begin(); it != d->directChats.end();)
+        {
+            if (it.value() == roomId)
+                it = d->directChats.erase(it);
+            else
+                ++it;
+        }
+    d->broadcastDirectChatUpdates();
+}
+
+bool Connection::isDirectChat(const QString& roomId) const
+{
+    return d->directChats.key(roomId) != nullptr;
+}
+
+QList<const User*> Connection::directChatUsers(const Room* room) const
+{
+    Q_ASSERT(room != nullptr);
+    return d->directChats.keys(room->id());
+}
+
 QMap<QString, User*> Connection::users() const
 {
     return d->userMap;
@@ -626,7 +791,7 @@ void Connection::setHomeserver(const QUrl& url)
     emit homeserverChanged(homeserver());
 }
 
-static constexpr int CACHE_VERSION_MAJOR = 3;
+static constexpr int CACHE_VERSION_MAJOR = 7;
 static constexpr int CACHE_VERSION_MINOR = 0;
 
 void Connection::saveState(const QUrl &toFile) const
@@ -652,39 +817,60 @@ void Connection::saveState(const QUrl &toFile) const
         return;
     }
 
-    QJsonObject roomObj;
+    QJsonObject rootObj;
     {
         QJsonObject rooms;
         QJsonObject inviteRooms;
-        for (auto i : roomMap()) // Pass on rooms in Leave state
+        for (const auto* i : roomMap()) // Pass on rooms in Leave state
         {
             if (i->joinState() == JoinState::Invite)
                 inviteRooms.insert(i->id(), i->toJson());
             else
                 rooms.insert(i->id(), i->toJson());
+            QElapsedTimer et1; et1.start();
+            QCoreApplication::processEvents();
+            if (et1.elapsed() > 1)
+                qCDebug(PROFILER) << "processEvents() borrowed" << et1;
         }
 
+        QJsonObject roomObj;
         if (!rooms.isEmpty())
             roomObj.insert("join", rooms);
         if (!inviteRooms.isEmpty())
             roomObj.insert("invite", inviteRooms);
+
+        rootObj.insert("next_batch", d->data->lastEvent());
+        rootObj.insert("rooms", roomObj);
     }
+    {
+        QJsonArray accountDataEvents {
+            QJsonObject {
+                { QStringLiteral("type"), QStringLiteral("m.direct") },
+                { QStringLiteral("content"), toJson(d->directChats) }
+            }
+        };
 
-    QJsonObject rootObj;
-    rootObj.insert("next_batch", d->data->lastEvent());
-    rootObj.insert("rooms", roomObj);
+        for (auto it = d->accountData.begin(); it != d->accountData.end(); ++it)
+            accountDataEvents.append(QJsonObject {
+                {"type", it.key()},
+                {"content", QJsonObject::fromVariantHash(it.value())}
+            });
+        rootObj.insert("account_data",
+            QJsonObject {{ QStringLiteral("events"), accountDataEvents }});
+    }
 
     QJsonObject versionObj;
     versionObj.insert("major", CACHE_VERSION_MAJOR);
     versionObj.insert("minor", CACHE_VERSION_MINOR);
     rootObj.insert("cache_version", versionObj);
 
-    QByteArray data = QJsonDocument(rootObj).toJson(QJsonDocument::Compact);
+    QJsonDocument json { rootObj };
+    auto data = d->cacheToBinary ? json.toBinaryData() :
+                                   json.toJson(QJsonDocument::Compact);
+    qCDebug(PROFILER) << "Cache for" << userId() << "generated in" << et;
 
-    qCDebug(MAIN) << "Writing state to file" << outfile.fileName();
     outfile.write(data.data(), data.size());
-    qCDebug(PROFILER) << "*** Cached state for" << userId()
-                      << "saved in" << et.elapsed() << "ms";
+    qCDebug(MAIN) << "State cache saved to" << outfile.fileName();
 }
 
 void Connection::loadState(const QUrl &fromFile)
@@ -701,28 +887,36 @@ void Connection::loadState(const QUrl &fromFile)
         qCDebug(MAIN) << "No state cache file found";
         return;
     }
-    file.open(QFile::ReadOnly);
+    if(!file.open(QFile::ReadOnly))
+    {
+        qCWarning(MAIN) << "file " << file.fileName() << "failed to open for read";
+        return;
+    }
     QByteArray data = file.readAll();
 
-    auto jsonDoc = QJsonDocument::fromJson(data);
+    auto jsonDoc = d->cacheToBinary ? QJsonDocument::fromBinaryData(data) :
+                                      QJsonDocument::fromJson(data);
+    if (jsonDoc.isNull())
+    {
+        qCWarning(MAIN) << "Cache file broken, discarding";
+        return;
+    }
     auto actualCacheVersionMajor =
             jsonDoc.object()
             .value("cache_version").toObject()
             .value("major").toInt();
     if (actualCacheVersionMajor < CACHE_VERSION_MAJOR)
     {
-        qCWarning(MAIN) << "Major version of the cache file is"
-                        << actualCacheVersionMajor << "but"
-                        << CACHE_VERSION_MAJOR
-                        << "required; discarding the cache";
+        qCWarning(MAIN)
+            << "Major version of the cache file is" << actualCacheVersionMajor
+            << "but" << CACHE_VERSION_MAJOR << "required; discarding the cache";
         return;
     }
 
     SyncData sync;
     sync.parseJson(jsonDoc);
     onSyncSuccess(std::move(sync));
-    qCDebug(PROFILER) << "*** Cached state for" << userId()
-                      << "loaded in" << et.elapsed() << "ms";
+    qCDebug(PROFILER) << "*** Cached state for" << userId() << "loaded in" << et;
 }
 
 QString Connection::stateCachePath() const
diff --git a/connection.h b/connection.h
index b45a171d..c6d543ec 100644
--- a/connection.h
+++ b/connection.h
@@ -83,15 +83,53 @@ namespace QMatrixClient
              */
             QHash<QString, QVector<Room*>> tagsToRooms() const;
 
+            /** Get all room tags known on this connection */
+            QStringList tagNames() const;
+
             /** Get the list of rooms with the specified tag */
             QVector<Room*> roomsWithTag(const QString& tagName) const;
 
+            /** Mark the room as a direct chat with the user
+             * This function marks \p room as a direct chat with \p user.
+             * Emits the signal synchronously, without waiting to complete
+             * synchronisation with the server.
+             *
+             * \sa directChatsListChanged
+             */
+            void addToDirectChats(const Room* room, const User* user);
+
+            /** Unmark the room from direct chats
+             * This function removes the room id from direct chats either for
+             * a specific \p user or for all users if \p user in nullptr.
+             * The room id is used to allow removal of, e.g., ids of forgotten
+             * rooms; a Room object need not exist. Emits the signal
+             * immediately, without waiting to complete synchronisation with
+             * the server.
+             *
+             * \sa directChatsListChanged
+             */
+            void removeFromDirectChats(const QString& roomId,
+                                       const User* user = nullptr);
+
+            /** Check whether the room id corresponds to a direct chat */
+            bool isDirectChat(const QString& roomId) const;
+
+            /** Retrieve the list of users the room is a direct chat with
+             * @return The list of users for which this room is marked as
+             * a direct chat; an empty list if the room is not a direct chat
+             */
+            QList<const User*> directChatUsers(const Room* room) const;
+
             QMap<QString, User*> users() const;
 
             // FIXME: Convert Q_INVOKABLEs to Q_PROPERTIES
             // (breaks back-compatibility)
             QUrl homeserver() const;
+            Q_INVOKABLE Room* room(const QString& roomId,
+                 JoinStates states = JoinState::Invite|JoinState::Join) const;
+            Q_INVOKABLE Room* invitation(const QString& roomId) const;
             Q_INVOKABLE User* user(const QString& userId);
+            const User* user() const;
             User* user();
             QString userId() const;
             QString deviceId() const;
@@ -220,7 +258,30 @@ namespace QMatrixClient
                 const QVector<CreateRoomJob::Invite3pid>& invite3pids = {},
                 const QJsonObject creationContent = {});
 
-            /** Create a direct chat with a single user, optional name and topic */
+            /** Get a direct chat with a single user
+             * This method may return synchronously or asynchoronously depending
+             * on whether a direct chat room with the respective person exists
+             * already.
+             *
+             * \sa directChatAvailable
+             */
+            Q_INVOKABLE void requestDirectChat(const QString& userId);
+
+            /** Run an operation in a direct chat with the user
+             * This method may return synchronously or asynchoronously depending
+             * on whether a direct chat room with the respective person exists
+             * already. Instead of emitting a signal it executes the passed
+             * function object with the direct chat room as its parameter.
+             */
+            Q_INVOKABLE void doInDirectChat(const QString& userId,
+                                            std::function<void(Room*)> operation);
+
+            /** Create a direct chat with a single user, optional name and topic
+             * A room will always be created, unlike in requestDirectChat.
+             * It is advised to use requestDirectChat as a default way of getting
+             * one-on-one with a person, and only use createDirectChat when
+             * a new creation is explicitly desired.
+             */
             CreateRoomJob* createDirectChat(const QString& userId,
                 const QString& topic = {}, const QString& name = {});
 
@@ -338,13 +399,30 @@ namespace QMatrixClient
             /** The room object is about to be deleted */
             void aboutToDeleteRoom(Room* room);
 
-            /** The room has just been created by createRoom or createDirectChat
+            /** The room has just been created by createRoom or requestDirectChat
+             *
              * This signal is not emitted in usual room state transitions,
              * only as an outcome of room creation operations invoked by
              * the client.
+             * \note requestDirectChat doesn't necessarily create a new chat;
+             *       use directChatAvailable signal if you just need to obtain
+             *       a direct chat room.
              */
             void createdRoom(Room* room);
 
+            /** The direct chat room is ready for using
+             * This signal is emitted upon any successful outcome from
+             * requestDirectChat.
+             */
+            void directChatAvailable(Room* directChat);
+
+            /** The list of direct chats has changed
+             * This signal is emitted every time when the mapping of users
+             * to direct chat rooms is changed (because of either local updates
+             * or a different list arrived from the server).
+             */
+            void directChatsListChanged();
+
             void cacheStateChanged();
 
         protected:
diff --git a/converters.h b/converters.h
index 0d7f734e..bba298e0 100644
--- a/converters.h
+++ b/converters.h
@@ -24,14 +24,16 @@
 
 namespace QMatrixClient
 {
-    template <typename T>
-    inline QJsonValue toJson(T&& val)
-    {
-        return QJsonValue(std::forward<T>(val));
-    }
+    // This catches anything implicitly convertible to QJsonValue/Object/Array
+    inline QJsonValue toJson(const QJsonValue& val) { return val; }
+    inline QJsonObject toJson(const QJsonObject& o) { return o; }
+    inline QJsonArray toJson(const QJsonArray& arr) { return arr; }
+#ifdef _MSC_VER // MSVC gets lost and doesn't know which overload to use
+    inline QJsonValue toJson(const QString& s) { return s; }
+#endif
 
     template <typename T>
-    inline QJsonValue toJson(const QVector<T>& vals)
+    inline QJsonArray toJson(const QVector<T>& vals)
     {
         QJsonArray ar;
         for (const auto& v: vals)
@@ -39,7 +41,7 @@ namespace QMatrixClient
         return ar;
     }
 
-    inline QJsonValue toJson(const QStringList& strings)
+    inline QJsonArray toJson(const QStringList& strings)
     {
         return QJsonArray::fromStringList(strings);
     }
@@ -50,9 +52,18 @@ namespace QMatrixClient
     }
 
     template <typename T>
+    inline QJsonObject toJson(const QHash<QString, T>& hashMap)
+    {
+        QJsonObject json;
+        for (auto it = hashMap.begin(); it != hashMap.end(); ++it)
+            json.insert(it.key(), toJson(it.value()));
+        return json;
+    }
+
+    template <typename T>
     struct FromJson
     {
-        T operator()(QJsonValue jv) const { return static_cast<T>(jv); }
+        T operator()(const QJsonValue& jv) const { return static_cast<T>(jv); }
     };
 
     template <typename T>
@@ -63,32 +74,32 @@ namespace QMatrixClient
 
     template <> struct FromJson<bool>
     {
-        bool operator()(QJsonValue jv) const { return jv.toBool(); }
+        bool operator()(const QJsonValue& jv) const { return jv.toBool(); }
     };
 
     template <> struct FromJson<int>
     {
-        int operator()(QJsonValue jv) const { return jv.toInt(); }
+        int operator()(const QJsonValue& jv) const { return jv.toInt(); }
     };
 
     template <> struct FromJson<double>
     {
-        double operator()(QJsonValue jv) const { return jv.toDouble(); }
+        double operator()(const QJsonValue& jv) const { return jv.toDouble(); }
     };
 
     template <> struct FromJson<qint64>
     {
-        qint64 operator()(QJsonValue jv) const { return qint64(jv.toDouble()); }
+        qint64 operator()(const QJsonValue& jv) const { return qint64(jv.toDouble()); }
     };
 
     template <> struct FromJson<QString>
     {
-        QString operator()(QJsonValue jv) const { return jv.toString(); }
+        QString operator()(const QJsonValue& jv) const { return jv.toString(); }
     };
 
     template <> struct FromJson<QDateTime>
     {
-        QDateTime operator()(QJsonValue jv) const
+        QDateTime operator()(const QJsonValue& jv) const
         {
             return QDateTime::fromMSecsSinceEpoch(fromJson<qint64>(jv), Qt::UTC);
         }
@@ -96,7 +107,7 @@ namespace QMatrixClient
 
     template <> struct FromJson<QDate>
     {
-        QDate operator()(QJsonValue jv) const
+        QDate operator()(const QJsonValue& jv) const
         {
             return fromJson<QDateTime>(jv).date();
         }
@@ -104,17 +115,23 @@ namespace QMatrixClient
 
     template <> struct FromJson<QJsonObject>
     {
-        QJsonObject operator()(QJsonValue jv) const { return jv.toObject(); }
+        QJsonObject operator()(const QJsonValue& jv) const
+        {
+            return jv.toObject();
+        }
     };
 
     template <> struct FromJson<QJsonArray>
     {
-        QJsonArray operator()(QJsonValue jv) const { return jv.toArray(); }
+        QJsonArray operator()(const QJsonValue& jv) const
+        {
+            return jv.toArray();
+        }
     };
 
     template <typename T> struct FromJson<QVector<T>>
     {
-        QVector<T> operator()(QJsonValue jv) const
+        QVector<T> operator()(const QJsonValue& jv) const
         {
             const auto jsonArray = jv.toArray();
             QVector<T> vect; vect.resize(jsonArray.size());
@@ -126,7 +143,7 @@ namespace QMatrixClient
 
     template <typename T> struct FromJson<QList<T>>
     {
-        QList<T> operator()(QJsonValue jv) const
+        QList<T> operator()(const QJsonValue& jv) const
         {
             const auto jsonArray = jv.toArray();
             QList<T> sl; sl.reserve(jsonArray.size());
@@ -140,10 +157,21 @@ namespace QMatrixClient
 
     template <> struct FromJson<QByteArray>
     {
-        QByteArray operator()(QJsonValue jv) const
+        inline QByteArray operator()(const QJsonValue& jv) const
         {
             return fromJson<QString>(jv).toLatin1();
         }
     };
 
+    template <typename T> struct FromJson<QHash<QString, T>>
+    {
+        QHash<QString, T> operator()(const QJsonValue& jv) const
+        {
+            const auto json = jv.toObject();
+            QHash<QString, T> h; h.reserve(json.size());
+            for (auto it = json.begin(); it != json.end(); ++it)
+                h.insert(it.key(), fromJson<T>(it.value()));
+            return h;
+        }
+    };
 }  // namespace QMatrixClient
diff --git a/events/accountdataevents.h b/events/accountdataevents.h
new file mode 100644
index 00000000..f3ba27bb
--- /dev/null
+++ b/events/accountdataevents.h
@@ -0,0 +1,78 @@
+#include <utility>
+
+/******************************************************************************
+ * Copyright (C) 2018 Kitsune Ral <kitsune-ral@users.sf.net>
+ *
+ * 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
+ */
+
+#pragma once
+
+#include "event.h"
+#include "eventcontent.h"
+
+namespace QMatrixClient
+{
+    static constexpr const char* FavouriteTag = "m.favourite";
+    static constexpr const char* LowPriorityTag = "m.lowpriority";
+
+    struct TagRecord
+    {
+        TagRecord (QString order = {}) : order(std::move(order)) { }
+        explicit TagRecord(const QJsonValue& jv)
+            : order(jv.toObject().value("order").toString())
+        { }
+
+        QString order;
+
+        bool operator==(const TagRecord& other) const
+            { return order == other.order; }
+        bool operator!=(const TagRecord& other) const
+            { return !operator==(other); }
+    };
+
+    inline QJsonValue toJson(const TagRecord& rec)
+    {
+        return QJsonObject {{ QStringLiteral("order"), rec.order }};
+    }
+
+    using TagsMap = QHash<QString, TagRecord>;
+
+#define DEFINE_SIMPLE_EVENT(_Name, _TypeId, _EnumType, _ContentType, _ContentKey) \
+    class _Name : public Event \
+    { \
+        public: \
+            static constexpr const char* TypeId = _TypeId; \
+            static const char* typeId() { return TypeId; } \
+            explicit _Name(const QJsonObject& obj) \
+                : Event((_EnumType), obj) \
+                , _content(contentJson(), QStringLiteral(#_ContentKey)) \
+            { } \
+            template <typename... Ts> \
+            explicit _Name(Ts&&... contentArgs) \
+                : Event(_EnumType) \
+                , _content(QStringLiteral(#_ContentKey), \
+                           std::forward<Ts>(contentArgs)...) \
+            { } \
+            const _ContentType& _ContentKey() const { return _content.value; } \
+            QJsonObject toJson() const { return _content.toJson(); } \
+        protected: \
+            EventContent::SimpleContent<_ContentType> _content; \
+    };
+
+    DEFINE_SIMPLE_EVENT(TagEvent, "m.tag", EventType::Tag, TagsMap, tags)
+    DEFINE_SIMPLE_EVENT(ReadMarkerEvent, "m.fully_read", EventType::ReadMarker,
+                        QString, event_id)
+}
diff --git a/events/tagevent.cpp b/events/directchatevent.cpp
index c6297003..7049d967 100644
--- a/events/tagevent.cpp
+++ b/events/directchatevent.cpp
@@ -16,35 +16,21 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include "tagevent.h"
+#include "directchatevent.h"
+
+#include "converters.h"
 
 using namespace QMatrixClient;
 
-TagRecord::TagRecord(const QJsonObject& json)
-    : order(json.value("order").toString())
+DirectChatEvent::DirectChatEvent(const QJsonObject& obj)
+    : Event(Type::DirectChat, obj)
 { }
 
-TagEvent::TagEvent(const QJsonObject& obj)
-    : Event(Type::Tag, obj)
-{
-    Q_ASSERT(obj["type"].toString() == TypeId);
-}
-
-QStringList TagEvent::tagNames() const
-{
-    return tagsObject().keys();
-}
-
-QHash<QString, TagRecord> TagEvent::tags() const
+QMultiHash<QString, QString> DirectChatEvent::usersToDirectChats() const
 {
-    QHash<QString, TagRecord> result;
-    auto allTags { tagsObject() };
-    for (auto it = allTags.begin(); it != allTags.end(); ++ it)
-        result.insert(it.key(), TagRecord(it.value().toObject()));
+    QMultiHash<QString, QString> result;
+    for (auto it = contentJson().begin(); it != contentJson().end(); ++it)
+        for (auto roomIdValue: it.value().toArray())
+            result.insert(it.key(), roomIdValue.toString());
     return result;
 }
-
-QJsonObject TagEvent::tagsObject() const
-{
-    return contentJson().value("tags").toObject();
-}
diff --git a/events/tagevent.h b/events/directchatevent.h
index 44a7e49a..2b0ad0a0 100644
--- a/events/tagevent.h
+++ b/events/directchatevent.h
@@ -22,30 +22,13 @@
 
 namespace QMatrixClient
 {
-    static constexpr const char* FavouriteTag = "m.favourite";
-    static constexpr const char* LowPriorityTag = "m.lowpriority";
-
-    struct TagRecord
-    {
-        explicit TagRecord(const QJsonObject& json = {});
-
-        QString order;
-    };
-
-    class TagEvent : public Event
+    class DirectChatEvent : public Event
     {
         public:
-            explicit TagEvent(const QJsonObject& obj);
-
-            /** Get the list of tag names */
-            QStringList tagNames() const;
-
-            /** Get the list of tags along with information on each */
-            QHash<QString, TagRecord> tags() const;
+            explicit DirectChatEvent(const QJsonObject& obj);
 
-            static constexpr const char * TypeId = "m.tag";
+            QMultiHash<QString, QString> usersToDirectChats() const;
 
-        protected:
-            QJsonObject tagsObject() const;
+            static constexpr const char * TypeId = "m.direct";
     };
 }
diff --git a/events/event.cpp b/events/event.cpp
index 74a2c3d7..8ddf3945 100644
--- a/events/event.cpp
+++ b/events/event.cpp
@@ -24,7 +24,8 @@
 #include "roomavatarevent.h"
 #include "typingevent.h"
 #include "receiptevent.h"
-#include "tagevent.h"
+#include "accountdataevents.h"
+#include "directchatevent.h"
 #include "redactionevent.h"
 #include "logging.h"
 
@@ -88,7 +89,8 @@ EventPtr _impl::doMakeEvent<Event>(const QJsonObject& obj)
         return EventPtr(move(e));
 
     return EventPtr { makeIfMatches<Event,
-        TypingEvent, ReceiptEvent, TagEvent>(obj, obj["type"].toString()) };
+        TypingEvent, ReceiptEvent, TagEvent, ReadMarkerEvent, DirectChatEvent>(
+                    obj, obj["type"].toString()) };
 }
 
 RoomEvent::RoomEvent(Event::Type type) : Event(type) { }
diff --git a/events/event.h b/events/event.h
index f0ca2d15..eccfec41 100644
--- a/events/event.h
+++ b/events/event.h
@@ -45,7 +45,7 @@ namespace QMatrixClient
             enum class Type : quint16
             {
                 Unknown = 0,
-                Typing, Receipt, Tag, DirectChat,
+                Typing, Receipt, Tag, DirectChat, ReadMarker,
                 RoomEventBase = 0x1000,
                 RoomMessage = RoomEventBase + 1,
                 RoomEncryptedMessage, Redaction,
diff --git a/events/receiptevent.cpp b/events/receiptevent.cpp
index 3c4d34ee..7555db82 100644
--- a/events/receiptevent.cpp
+++ b/events/receiptevent.cpp
@@ -66,11 +66,5 @@ ReceiptEvent::ReceiptEvent(const QJsonObject& obj)
         }
         _eventsWithReceipts.push_back({eventIt.key(), std::move(receipts)});
     }
-    static const auto UnreadMsgsKey =
-        QStringLiteral("x-qmatrixclient.unread_messages");
-    if (contents.contains(UnreadMsgsKey))
-        _unreadMessages = contents["x-qmatrixclient.unread_messages"].toBool();
-    else
-        _unreadMessages = obj["x-qmatrixclient.unread_messages"].toBool();
 }
 
diff --git a/events/receiptevent.h b/events/receiptevent.h
index 92dace82..5b99ae3f 100644
--- a/events/receiptevent.h
+++ b/events/receiptevent.h
@@ -41,12 +41,10 @@ namespace QMatrixClient
 
             EventsWithReceipts eventsWithReceipts() const
             { return _eventsWithReceipts; }
-            bool unreadMessages() const { return _unreadMessages; }
 
             static constexpr const char* const TypeId = "m.receipt";
 
         private:
             EventsWithReceipts _eventsWithReceipts;
-            bool _unreadMessages; // Spec extension for caching purposes
     };
 }  // namespace QMatrixClient
diff --git a/events/roommemberevent.cpp b/events/roommemberevent.cpp
index a9e301a4..76b003c2 100644
--- a/events/roommemberevent.cpp
+++ b/events/roommemberevent.cpp
@@ -51,6 +51,7 @@ namespace QMatrixClient
 
 MemberEventContent::MemberEventContent(const QJsonObject& json)
     : membership(fromJson<MembershipType>(json["membership"]))
+    , isDirect(json["is_direct"].toBool())
     , displayName(json["displayname"].toString())
     , avatarUrl(json["avatar_url"].toString())
 { }
diff --git a/events/roommemberevent.h b/events/roommemberevent.h
index b9ff0d70..89b970c9 100644
--- a/events/roommemberevent.h
+++ b/events/roommemberevent.h
@@ -38,6 +38,7 @@ namespace QMatrixClient
             explicit MemberEventContent(const QJsonObject& json);
 
             MembershipType membership;
+            bool isDirect = false;
             QString displayName;
             QUrl avatarUrl;
 
@@ -66,6 +67,7 @@ namespace QMatrixClient
             MembershipType membership() const  { return content().membership; }
             QString userId() const
             { return originalJsonObject().value("state_key").toString(); }
+            bool isDirect() const { return content().isDirect; }
             QString displayName() const { return content().displayName; }
             QUrl avatarUrl() const      { return content().avatarUrl; }
 
diff --git a/events/simplestateevents.h b/events/simplestateevents.h
index d5841bdc..6b0cd51a 100644
--- a/events/simplestateevents.h
+++ b/events/simplestateevents.h
@@ -19,36 +19,35 @@
 #pragma once
 
 #include "event.h"
-
 #include "eventcontent.h"
 
 namespace QMatrixClient
 {
-#define DECLARE_SIMPLE_STATE_EVENT(_Name, _TypeId, _EnumType, _ContentType, _ContentKey) \
+#define DEFINE_SIMPLE_STATE_EVENT(_Name, _TypeId, _EnumType, _ContentType, _ContentKey) \
     class _Name \
         : public StateEvent<EventContent::SimpleContent<_ContentType>> \
     { \
         public: \
             static constexpr const char* TypeId = _TypeId; \
             explicit _Name(const QJsonObject& obj) \
-                : StateEvent(_EnumType, obj, #_ContentKey) \
+                : StateEvent(_EnumType, obj, QStringLiteral(#_ContentKey)) \
             { } \
             template <typename T> \
             explicit _Name(T&& value) \
-                : StateEvent(_EnumType, #_ContentKey, \
+                : StateEvent(_EnumType, QStringLiteral(#_ContentKey), \
                              std::forward<T>(value)) \
             { } \
-            _ContentType _ContentKey() const { return content().value; } \
+            const _ContentType& _ContentKey() const { return content().value; } \
     };
 
-    DECLARE_SIMPLE_STATE_EVENT(RoomNameEvent, "m.room.name",
-                               Event::Type::RoomName, QString, name)
-    DECLARE_SIMPLE_STATE_EVENT(RoomAliasesEvent, "m.room.aliases",
-                               Event::Type::RoomAliases, QStringList, aliases)
-    DECLARE_SIMPLE_STATE_EVENT(RoomCanonicalAliasEvent, "m.room.canonical_alias",
-                               Event::Type::RoomCanonicalAlias, QString, alias)
-    DECLARE_SIMPLE_STATE_EVENT(RoomTopicEvent, "m.room.topic",
-                               Event::Type::RoomTopic, QString, topic)
-    DECLARE_SIMPLE_STATE_EVENT(EncryptionEvent, "m.room.encryption",
-                               Event::Type::RoomEncryption, QString, algorithm)
+    DEFINE_SIMPLE_STATE_EVENT(RoomNameEvent, "m.room.name",
+                              Event::Type::RoomName, QString, name)
+    DEFINE_SIMPLE_STATE_EVENT(RoomAliasesEvent, "m.room.aliases",
+                              Event::Type::RoomAliases, QStringList, aliases)
+    DEFINE_SIMPLE_STATE_EVENT(RoomCanonicalAliasEvent, "m.room.canonical_alias",
+                              Event::Type::RoomCanonicalAlias, QString, alias)
+    DEFINE_SIMPLE_STATE_EVENT(RoomTopicEvent, "m.room.topic",
+                              Event::Type::RoomTopic, QString, topic)
+    DEFINE_SIMPLE_STATE_EVENT(EncryptionEvent, "m.room.encryption",
+                              Event::Type::RoomEncryption, QString, algorithm)
 } // namespace QMatrixClient
diff --git a/examples/qmc-example.cpp b/examples/qmc-example.cpp
index e0aabca9..23a1bff1 100644
--- a/examples/qmc-example.cpp
+++ b/examples/qmc-example.cpp
@@ -2,45 +2,103 @@
 #include "connection.h"
 #include "room.h"
 #include "user.h"
+#include "jobs/sendeventjob.h"
 
 #include <QtCore/QCoreApplication>
 #include <QtCore/QStringBuilder>
+#include <QtCore/QTimer>
 #include <iostream>
+#include <functional>
 
 using namespace QMatrixClient;
 using std::cout;
 using std::endl;
-using std::bind;
 using namespace std::placeholders;
 
-void onNewRoom(Room* r, const char* targetRoomName)
+class QMCTest : public QObject
+{
+    public:
+        QMCTest(Connection* conn, const QString& testRoomName, QString source);
+
+    private slots:
+        void onNewRoom(Room* r, const QString& testRoomName);
+            void doTests();
+                void addAndRemoveTag();
+                void sendAndRedact();
+                    void checkRedactionOutcome(QString evtIdToRedact, RoomEventsRange events);
+                void markDirectChat();
+                    void checkDirectChatOutcome();
+        void finalize();
+
+    private:
+        QScopedPointer<Connection, QScopedPointerDeleteLater> c;
+        QString origin;
+        Room* targetRoom = nullptr;
+        int semaphor = 0;
+
+};
+
+#define QMC_CHECK(description, condition) \
+{ \
+    cout << (description) \
+         << (!!(condition) ? " successul" : " FAILED") << endl; \
+    targetRoom->postMessage(origin % ": " % QStringLiteral(description) % \
+        (!!(condition) ? QStringLiteral(" successful") : \
+                         QStringLiteral(" FAILED")), \
+        !!(condition) ? MessageEventType::Notice : MessageEventType::Text); \
+    --semaphor; \
+}
+
+QMCTest::QMCTest(Connection* conn, const QString& testRoomName, QString source)
+    : c(conn), origin(std::move(source))
+{
+    if (!origin.isEmpty())
+        cout << "Origin for the test message: " << origin.toStdString() << endl;
+    if (!testRoomName.isEmpty())
+        cout << "Test room name: " << testRoomName.toStdString() << endl;
+
+    connect(c.data(), &Connection::newRoom,
+            this, [this,testRoomName] (Room* r) { onNewRoom(r, testRoomName); });
+    connect(c.data(), &Connection::syncDone, c.data(), [this] {
+        cout << "Sync complete, " << semaphor << " tests in the air" << endl;
+        if (semaphor)
+            c->sync(10000);
+        else if (targetRoom)
+        {
+            auto j = c->callApi<SendEventJob>(targetRoom->id(),
+                    RoomMessageEvent(origin % ": All tests finished"));
+            connect(j, &BaseJob::finished, this, &QMCTest::finalize);
+        }
+        else
+            finalize();
+    });
+    // Big countdown watchdog
+    QTimer::singleShot(180000, this, &QMCTest::finalize);
+}
+
+void QMCTest::onNewRoom(Room* r, const QString& testRoomName)
 {
     cout << "New room: " << r->id().toStdString() << endl;
-    QObject::connect(r, &Room::namesChanged, [=] {
+    connect(r, &Room::namesChanged, this, [=] {
         cout << "Room " << r->id().toStdString() << ", name(s) changed:" << endl
              << "  Name: " << r->name().toStdString() << endl
              << "  Canonical alias: " << r->canonicalAlias().toStdString() << endl
              << endl << endl;
-        if (targetRoomName && (r->name() == targetRoomName ||
-                r->canonicalAlias() == targetRoomName))
+        if (!testRoomName.isEmpty() && (r->name() == testRoomName ||
+                r->canonicalAlias() == testRoomName))
         {
-            r->postMessage(
-                "This is a test message from an example application\n"
-                "The current user is " % r->localUser()->fullName(r) % "\n" %
-                QStringLiteral("This room has %1 member(s)")
-                    .arg(r->memberCount()) % "\n" %
-//                "The room is " %
-//                    (r->isDirectChat() ? "" : "not ") % "a direct chat\n" %
-                "Have a good day",
-                MessageEventType::Notice
-            );
+            cout << "Found the target room, proceeding for tests" << endl;
+            targetRoom = r;
+            ++semaphor;
+            auto j = targetRoom->connection()->callApi<SendEventJob>(
+                targetRoom->id(),
+                RoomMessageEvent(origin % ": connected to test room",
+                MessageEventType::Notice));
+            connect(j, &BaseJob::success,
+                    this, [this] { doTests(); --semaphor; });
         }
     });
-    QObject::connect(r, &Room::tagsChanged, [=] {
-        cout << "Room " << r->id().toStdString() << ", tag(s) changed:" << endl
-             << "  " << r->tagNames().join(", ").toStdString() << endl << endl;
-    });
-    QObject::connect(r, &Room::aboutToAddNewMessages, [=] (RoomEventsRange timeline) {
+    connect(r, &Room::aboutToAddNewMessages, r, [r] (RoomEventsRange timeline) {
         cout << timeline.size() << " new event(s) in room "
              << r->id().toStdString() << endl;
 //        for (const auto& item: timeline)
@@ -54,39 +112,164 @@ void onNewRoom(Room* r, const char* targetRoomName)
     });
 }
 
-void finalize(Connection* conn)
+void QMCTest::doTests()
+{
+    ++semaphor; addAndRemoveTag();
+    ++semaphor; sendAndRedact();
+    ++semaphor; markDirectChat();
+}
+
+void QMCTest::addAndRemoveTag()
+{
+    static const auto TestTag = QStringLiteral("org.qmatrixclient.test");
+    // Pre-requisite
+    if (targetRoom->tags().contains(TestTag))
+        targetRoom->removeTag(TestTag);
+
+    // Connect first because the signal is emitted synchronously.
+    connect(targetRoom, &Room::tagsChanged, targetRoom, [=] {
+        cout << "Room " << targetRoom->id().toStdString()
+             << ", tag(s) changed:" << endl
+             << "  " << targetRoom->tagNames().join(", ").toStdString() << endl;
+        if (targetRoom->tags().contains(TestTag))
+        {
+            cout << "Test tag set, removing it now" << endl;
+            targetRoom->removeTag(TestTag);
+            QMC_CHECK("Tagging test", !targetRoom->tags().contains(TestTag));
+            QObject::disconnect(targetRoom, &Room::tagsChanged, nullptr, nullptr);
+        }
+    });
+    cout << "Adding a tag" << endl;
+    targetRoom->addTag(TestTag);
+}
+
+void QMCTest::sendAndRedact()
+{
+    cout << "Sending a message to redact" << endl;
+    auto* job = targetRoom->connection()->callApi<SendEventJob>(targetRoom->id(),
+            RoomMessageEvent(origin % ": Message to redact"));
+    connect(job, &BaseJob::success, targetRoom, [job,this] {
+        cout << "Message to redact has been succesfully sent, redacting" << endl;
+        targetRoom->redactEvent(job->eventId(), origin);
+        // Make sure to save the event id because the job is about to end.
+        connect(targetRoom, &Room::aboutToAddNewMessages, this,
+                std::bind(&QMCTest::checkRedactionOutcome,
+                          this, job->eventId(), _1));
+    });
+}
+
+void QMCTest::checkRedactionOutcome(QString evtIdToRedact,
+                                    RoomEventsRange events)
+{
+    static bool checkSucceeded = false;
+    // There are two possible (correct) outcomes: either the event comes already
+    // redacted at the next sync, or the nearest sync completes with
+    // the unredacted event but the next one brings redaction.
+    auto it = std::find_if(events.begin(), events.end(),
+                [=] (const RoomEventPtr& e) {
+                    return e->id() == evtIdToRedact;
+                });
+    if (it == events.end())
+        return; // Waiting for the next sync
+
+    if ((*it)->isRedacted())
+    {
+        if (checkSucceeded)
+        {
+            const auto msg =
+                    "The redacted event came in with the sync again, ignoring";
+            cout << msg << endl;
+            targetRoom->postMessage(msg);
+            return;
+        }
+        cout << "The sync brought already redacted message" << endl;
+        QMC_CHECK("Redaction", true);
+        // Not disconnecting because there are other connections from this class
+        // to aboutToAddNewMessages
+        checkSucceeded = true;
+        return;
+    }
+    // The event is not redacted
+    if (checkSucceeded)
+    {
+        const auto msg =
+                "Warning: the redacted event came non-redacted with the sync!";
+        cout << msg << endl;
+        targetRoom->postMessage(msg);
+    }
+    cout << "Message came non-redacted with the sync, waiting for redaction" << endl;
+    connect(targetRoom, &Room::replacedEvent, targetRoom,
+        [=] (const RoomEvent* newEvent, const RoomEvent* oldEvent) {
+            QMC_CHECK("Redaction", oldEvent->id() == evtIdToRedact &&
+                      newEvent->isRedacted() &&
+                      newEvent->redactionReason() == origin);
+            checkSucceeded = true;
+            disconnect(targetRoom, &Room::replacedEvent, nullptr, nullptr);
+        });
+
+}
+
+void QMCTest::markDirectChat()
+{
+    if (c->isDirectChat(targetRoom->id()))
+    {
+        cout << "Warning: the room is already a direct chat,"
+                " only unmarking will be tested" << endl;
+        checkDirectChatOutcome();
+    }
+    // Connect first because the signal is emitted synchronously.
+    connect(c.data(), &Connection::directChatsListChanged,
+            this, &QMCTest::checkDirectChatOutcome);
+    cout << "Marking the room as a direct chat" << endl;
+    c->addToDirectChats(targetRoom, c->user());
+}
+
+void QMCTest::checkDirectChatOutcome()
+{
+    disconnect(c.data(), &Connection::directChatsListChanged, nullptr, nullptr);
+    if (!c->isDirectChat(targetRoom->id()))
+    {
+        QMC_CHECK("Direct chat test", false);
+        return;
+    }
+
+    cout << "Room marked as a direct chat, unmarking now" << endl;
+    c->removeFromDirectChats(targetRoom->id(), c->user());
+    QMC_CHECK("Direct chat test", !c->isDirectChat(targetRoom->id()));
+}
+
+void QMCTest::finalize()
 {
+    if (semaphor)
+        cout << "One or more tests FAILED" << endl;
     cout << "Logging out" << endl;
-    conn->logout();
-    QObject::connect(conn, &Connection::loggedOut, QCoreApplication::instance(),
-        [conn] {
-            conn->deleteLater();
-            QCoreApplication::instance()->processEvents();
-            QCoreApplication::instance()->quit();
+    c->logout();
+    connect(c.data(), &Connection::loggedOut, QCoreApplication::instance(),
+        [this] {
+            QCoreApplication::processEvents();
+            QCoreApplication::exit(semaphor);
         });
 }
 
 int main(int argc, char* argv[])
 {
     QCoreApplication app(argc, argv);
-    if (argc < 3)
+    if (argc < 4)
+    {
+        cout << "Usage: qmc-example <user> <passwd> <device_name> [<room_alias> [origin]]" << endl;
         return -1;
+    }
 
     cout << "Connecting to the server as " << argv[1] << endl;
     auto conn = new Connection;
-    conn->connectToServer(argv[1], argv[2], "QMatrixClient example application");
+    conn->connectToServer(argv[1], argv[2], argv[3]);
     QObject::connect(conn, &Connection::connected, [=] {
         cout << "Connected, server: "
              << conn->homeserver().toDisplayString().toStdString() << endl;
         cout << "Access token: " << conn->accessToken().toStdString() << endl;
         conn->sync();
     });
-    const char* targetRoomName = argc >= 4 ? argv[3] : nullptr;
-    if (targetRoomName)
-        cout << "Target room name: " << targetRoomName;
-    QObject::connect(conn, &Connection::newRoom,
-                     bind(onNewRoom, _1, targetRoomName));
-    QObject::connect(conn, &Connection::syncDone,
-                     bind(finalize, conn));
+    QMCTest test { conn, argc >= 5 ? argv[4] : nullptr,
+                         argc >= 6 ? argv[5] : nullptr };
     return app.exec();
 }
diff --git a/jobs/basejob.cpp b/jobs/basejob.cpp
index 486956e1..0303af39 100644
--- a/jobs/basejob.cpp
+++ b/jobs/basejob.cpp
@@ -83,18 +83,6 @@ class BaseJob::Private
         LoggingCategory logCat = JOBS;
 };
 
-inline QDebug operator<<(QDebug dbg, const BaseJob* j)
-{
-    return dbg << j->objectName();
-}
-
-QDebug QMatrixClient::operator<<(QDebug dbg, const BaseJob::Status& s)
-{
-    QRegularExpression filter { "(access_token)(=|: )[-_A-Za-z0-9]+" };
-    return dbg << s.code << ':'
-               << QString(s.message).replace(filter, "\\1 HIDDEN");
-}
-
 BaseJob::BaseJob(HttpVerb verb, const QString& name, const QString& endpoint, bool needsToken)
     : BaseJob(verb, name, endpoint, Query { }, Data { }, needsToken)
 { }
@@ -234,8 +222,12 @@ void BaseJob::start(const ConnectionData* connData)
 {
     d->connection = connData;
     beforeStart(connData);
-    sendRequest();
-    afterStart(connData, d->reply.data());
+    if (status().good())
+        sendRequest();
+    if (status().good())
+        afterStart(connData, d->reply.data());
+    if (!status().good())
+        QTimer::singleShot(0, this, &BaseJob::finishJob);
 }
 
 void BaseJob::sendRequest()
@@ -268,9 +260,38 @@ void BaseJob::gotReply()
         setStatus(parseReply(d->reply.data()));
     else
     {
-        auto json = QJsonDocument::fromJson(d->reply->readAll()).object();
-        if (!json.isEmpty())
-            setStatus(IncorrectRequestError, json.value("error").toString());
+        const auto body = d->reply->readAll();
+        if (!body.isEmpty())
+        {
+            qCDebug(d->logCat).noquote() << "Error body:" << body;
+            auto json = QJsonDocument::fromJson(body).object();
+            if (json.isEmpty())
+                setStatus(IncorrectRequestError, body);
+            else {
+                if (error() == TooManyRequestsError ||
+                        json.value("errcode").toString() == "M_LIMIT_EXCEEDED")
+                {
+                    QString msg = tr("Too many requests");
+                    auto retryInterval = json.value("retry_after_ms").toInt(-1);
+                    if (retryInterval != -1)
+                        msg += tr(", next retry advised after %1 ms")
+                                .arg(retryInterval);
+                    else // We still have to figure some reasonable interval
+                        retryInterval = getNextRetryInterval();
+
+                    setStatus(TooManyRequestsError, msg);
+
+                    // Shortcut to retry instead of executing finishJob()
+                    stop();
+                    qCWarning(d->logCat)
+                            << this << "will retry in" << retryInterval;
+                    d->retryTimer.start(retryInterval);
+                    emit retryScheduled(d->retriesTaken, retryInterval);
+                    return;
+                }
+                setStatus(IncorrectRequestError, json.value("error").toString());
+            }
+        }
     }
 
     finishJob();
@@ -281,9 +302,12 @@ bool checkContentType(const QByteArray& type, const QByteArrayList& patterns)
     if (patterns.isEmpty())
         return true;
 
+    // ignore possible appendixes of the content type
+    const auto ctype = type.split(';').front();
+
     for (const auto& pattern: patterns)
     {
-        if (pattern.startsWith('*') || type == pattern) // Fast lane
+        if (pattern.startsWith('*') || ctype == pattern) // Fast lane
             return true;
 
         auto patternParts = pattern.split('/');
@@ -291,7 +315,7 @@ bool checkContentType(const QByteArray& type, const QByteArrayList& patterns)
             "BaseJob: Expected content type should have up to two"
             " /-separated parts; violating pattern: " + pattern);
 
-        if (type.split('/').front() == patternParts.front() &&
+        if (ctype.split('/').front() == patternParts.front() &&
                 patternParts.back() == "*")
             return true; // Exact match already went on fast lane
     }
@@ -301,17 +325,26 @@ bool checkContentType(const QByteArray& type, const QByteArrayList& patterns)
 
 BaseJob::Status BaseJob::checkReply(QNetworkReply* reply) const
 {
-    qCDebug(d->logCat) << this << "returned"
+    const auto httpCode =
+            reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    qCDebug(d->logCat).nospace().noquote() << this << " returned HTTP code "
+        << httpCode << ": "
         << (reply->error() == QNetworkReply::NoError ?
                 "Success" : reply->errorString())
-        << "from" << reply->url().toDisplayString();
+        << " (URL: " << reply->url().toDisplayString() << ")";
+
+    if (httpCode == 429) // Qt doesn't know about it yet
+        return { TooManyRequestsError, tr("Too many requests") };
+
+    // Should we check httpCode instead? Maybe even use it in BaseJob::Status?
+    // That would make codes in logs slightly more readable.
     switch( reply->error() )
     {
         case QNetworkReply::NoError:
             if (checkContentType(reply->rawHeader("Content-Type"),
                                  d->expectedContentTypes))
                 return NoError;
-            else
+            else // A warning in the logs might be more proper instead
                 return { IncorrectResponseError,
                          "Incorrect content type of the response" };
 
@@ -372,9 +405,10 @@ void BaseJob::finishJob()
         // TODO: The whole retrying thing should be put to ConnectionManager
         // otherwise independently retrying jobs make a bit of notification
         // storm towards the UI.
-        const auto retryInterval = getNextRetryInterval();
+        const auto retryInterval =
+                error() == TimeoutError ? 0 : getNextRetryInterval();
         ++d->retriesTaken;
-        qCWarning(d->logCat) << this << "will take retry" << d->retriesTaken
+        qCWarning(d->logCat) << this << "will retry" << d->retriesTaken
                    << "in" << retryInterval/1000 << "s";
         d->retryTimer.start(retryInterval);
         emit retryScheduled(d->retriesTaken, retryInterval);
@@ -447,6 +481,7 @@ void BaseJob::setStatus(Status s)
 
 void BaseJob::setStatus(int code, QString message)
 {
+    message.replace(d->connection->accessToken(), "(REDACTED)");
     setStatus({ code, message });
 }
 
diff --git a/jobs/basejob.h b/jobs/basejob.h
index a5b457c5..ed630a67 100644
--- a/jobs/basejob.h
+++ b/jobs/basejob.h
@@ -62,6 +62,7 @@ namespace QMatrixClient
                 , NotFoundError
                 , IncorrectRequestError
                 , IncorrectResponseError
+                , TooManyRequestsError
                 , UserDefinedError = 200
             };
 
@@ -98,7 +99,12 @@ namespace QMatrixClient
                     Status(int c, QString m) : code(c), message(std::move(m)) { }
 
                     bool good() const { return code < ErrorLevel; }
-                    friend QDebug operator<<(QDebug dbg, const Status& s);
+                    friend QDebug operator<<(QDebug dbg, const Status& s)
+                    {
+                        QDebug(dbg).noquote().nospace()
+                                << s.code << ": " << s.message;
+                        return dbg;
+                    }
 
                     int code;
                     QString message;
@@ -124,6 +130,11 @@ namespace QMatrixClient
             Q_INVOKABLE duration_t getNextRetryInterval() const;
             Q_INVOKABLE duration_t millisToRetry() const;
 
+            friend QDebug operator<<(QDebug dbg, const BaseJob* j)
+            {
+                return dbg << j->objectName();
+            }
+
         public slots:
             void start(const ConnectionData* connData);
 
diff --git a/jobs/downloadfilejob.cpp b/jobs/downloadfilejob.cpp
index 07d14197..6a3d8483 100644
--- a/jobs/downloadfilejob.cpp
+++ b/jobs/downloadfilejob.cpp
@@ -54,6 +54,7 @@ void DownloadFileJob::beforeStart(const ConnectionData*)
         qCWarning(JOBS) << "Couldn't open the temporary file"
                         << d->tempFile->fileName() << "for writing";
         setStatus(FileError, "Could not open the temporary download file");
+        return;
     }
     qCDebug(JOBS) << "Downloading to" << d->tempFile->fileName();
 }
diff --git a/jobs/postreadmarkersjob.h b/jobs/postreadmarkersjob.h
new file mode 100644
index 00000000..d0198821
--- /dev/null
+++ b/jobs/postreadmarkersjob.h
@@ -0,0 +1,37 @@
+/******************************************************************************
+ * Copyright (C) 2017 Kitsune Ral <kitsune-ral@users.sf.net>
+ *
+ * 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
+ */
+
+#pragma once
+
+#include "basejob.h"
+
+using namespace QMatrixClient;
+
+class PostReadMarkersJob : public BaseJob
+{
+    public:
+        explicit PostReadMarkersJob(const QString& roomId,
+                                    const QString& readUpToEventId)
+            : BaseJob(HttpVerb::Post, "PostReadMarkersJob",
+                      QStringLiteral("_matrix/client/r0/rooms/%1/read_markers")
+                      .arg(roomId))
+        {
+            setRequestData(QJsonObject {{
+                QStringLiteral("m.fully_read"), readUpToEventId }});
+        }
+};
diff --git a/jobs/syncjob.cpp b/jobs/syncjob.cpp
index 7b066f4f..435dfd0e 100644
--- a/jobs/syncjob.cpp
+++ b/jobs/syncjob.cpp
@@ -68,25 +68,30 @@ BaseJob::Status SyncData::parseJson(const QJsonDocument &data)
 {
     QElapsedTimer et; et.start();
 
-    auto json { data.object() };
+    auto json = data.object();
     nextBatch_ = json.value("next_batch").toString();
     // TODO: presence
     accountData.fromJson(json);
 
     QJsonObject rooms = json.value("rooms").toObject();
-    for (size_t i = 0; i < JoinStateStrings.size(); ++i)
+    JoinStates::Int ii = 1; // ii is used to make a JoinState value
+    for (size_t i = 0; i < JoinStateStrings.size(); ++i, ii <<= 1)
     {
         const auto rs = rooms.value(JoinStateStrings[i]).toObject();
         // We have a Qt container on the right and an STL one on the left
         roomData.reserve(static_cast<size_t>(rs.size()));
         for(auto roomIt = rs.begin(); roomIt != rs.end(); ++roomIt)
-            roomData.emplace_back(roomIt.key(), JoinState(i),
+            roomData.emplace_back(roomIt.key(), JoinState(ii),
                                   roomIt.value().toObject());
     }
-    qCDebug(PROFILER) << "*** SyncData::parseJson():" << et.elapsed() << "ms";
+    qCDebug(PROFILER) << "*** SyncData::parseJson(): batch with"
+                      << rooms.size() << "room(s) in" << et;
     return BaseJob::Success;
 }
 
+const QString SyncRoomData::UnreadCountKey =
+        QStringLiteral("x-qmatrixclient.unread_count");
+
 SyncRoomData::SyncRoomData(const QString& roomId_, JoinState joinState_,
                            const QJsonObject& room_)
     : roomId(roomId_)
@@ -114,12 +119,15 @@ SyncRoomData::SyncRoomData(const QString& roomId_, JoinState joinState_,
         qCWarning(SYNCJOB) << "SyncRoomData: Unknown JoinState value, ignoring:" << int(joinState);
     }
 
-    QJsonObject timeline = room_.value("timeline").toObject();
-    timelineLimited = timeline.value("limited").toBool();
-    timelinePrevBatch = timeline.value("prev_batch").toString();
-
-    QJsonObject unread = room_.value("unread_notifications").toObject();
-    highlightCount = unread.value("highlight_count").toInt();
-    notificationCount = unread.value("notification_count").toInt();
-    qCDebug(SYNCJOB) << "Highlights: " << highlightCount << " Notifications:" << notificationCount;
+    auto timelineJson = room_.value("timeline").toObject();
+    timelineLimited = timelineJson.value("limited").toBool();
+    timelinePrevBatch = timelineJson.value("prev_batch").toString();
+
+    auto unreadJson = room_.value("unread_notifications").toObject();
+    unreadCount = unreadJson.value(UnreadCountKey).toInt(-2);
+    highlightCount = unreadJson.value("highlight_count").toInt();
+    notificationCount = unreadJson.value("notification_count").toInt();
+    if (highlightCount > 0 || notificationCount > 0)
+        qCDebug(SYNCJOB) << "Highlights: " << highlightCount
+                         << " Notifications:" << notificationCount;
 }
diff --git a/jobs/syncjob.h b/jobs/syncjob.h
index 5956e73b..919060be 100644
--- a/jobs/syncjob.h
+++ b/jobs/syncjob.h
@@ -53,6 +53,7 @@ namespace QMatrixClient
 
             bool timelineLimited;
             QString timelinePrevBatch;
+            int unreadCount;
             int highlightCount;
             int notificationCount;
 
@@ -60,6 +61,8 @@ namespace QMatrixClient
                          const QJsonObject& room_);
             SyncRoomData(SyncRoomData&&) = default;
             SyncRoomData& operator=(SyncRoomData&&) = default;
+
+            static const QString UnreadCountKey;
     };
     // QVector cannot work with non-copiable objects, std::vector can.
     using SyncDataList = std::vector<SyncRoomData>;
diff --git a/joinstate.h b/joinstate.h
index d6c374d2..42613895 100644
--- a/joinstate.h
+++ b/joinstate.h
@@ -18,17 +18,21 @@
 
 #pragma once
 
+#include <QtCore/QFlags>
+
 #include <array>
 
 namespace QMatrixClient
 {
     enum class JoinState
     {
-        Join = 0,
-        Invite,
-        Leave
+        Join = 0x1,
+        Invite = 0x2,
+        Leave = 0x4
     };
 
+    Q_DECLARE_FLAGS(JoinStates, JoinState)
+
     // We cannot use REGISTER_ENUM outside of a Q_OBJECT and besides, we want
     // to use strings that match respective JSON keys.
     static const std::array<const char*, 3> JoinStateStrings
@@ -36,6 +40,9 @@ namespace QMatrixClient
 
     inline const char* toCString(JoinState js)
     {
-        return JoinStateStrings[size_t(js)];
+        size_t state = size_t(js), index = 0;
+        while (state >>= 1) ++index;
+        return JoinStateStrings[index];
     }
 }  // namespace QMatrixClient
+Q_DECLARE_OPERATORS_FOR_FLAGS(QMatrixClient::JoinStates)
diff --git a/libqmatrixclient.pri b/libqmatrixclient.pri
index 7cfa94a1..144c9dbc 100644
--- a/libqmatrixclient.pri
+++ b/libqmatrixclient.pri
@@ -24,7 +24,8 @@ HEADERS += \
     $$PWD/events/roomavatarevent.h \
     $$PWD/events/typingevent.h \
     $$PWD/events/receiptevent.h \
-    $$PWD/events/tagevent.h \
+    $$PWD/events/accountdataevents.h \
+    $$PWD/events/directchatevent.h \
     $$PWD/events/redactionevent.h \
     $$PWD/jobs/requestdata.h \
     $$PWD/jobs/basejob.h \
@@ -42,7 +43,8 @@ HEADERS += \
     $$PWD/settings.h \
     $$PWD/networksettings.h \
     $$PWD/networkaccessmanager.h \
-    $$PWD/jobs/downloadfilejob.h
+    $$PWD/jobs/downloadfilejob.h \
+    $$PWD/jobs/postreadmarkersjob.h
 
 SOURCES += \
     $$PWD/connectiondata.cpp \
@@ -56,7 +58,7 @@ SOURCES += \
     $$PWD/events/roommemberevent.cpp \
     $$PWD/events/typingevent.cpp \
     $$PWD/events/receiptevent.cpp \
-    $$PWD/events/tagevent.cpp \
+    $$PWD/events/directchatevent.cpp \
     $$PWD/jobs/requestdata.cpp \
     $$PWD/jobs/basejob.cpp \
     $$PWD/jobs/checkauthmethods.cpp \
diff --git a/logging.h b/logging.h
index aaeceeac..8dbfdf30 100644
--- a/logging.h
+++ b/logging.h
@@ -18,6 +18,7 @@
 
 #pragma once
 
+#include <QtCore/QElapsedTimer>
 #include <QtCore/QLoggingCategory>
 
 Q_DECLARE_LOGGING_CATEGORY(MAIN)
@@ -65,3 +66,13 @@ namespace QMatrixClient
         return qdm(debug_object);
     }
 }
+
+inline QDebug operator<< (QDebug debug_object, const QElapsedTimer& et)
+{
+    auto val = et.nsecsElapsed() / 1000;
+    if (val < 1000)
+        debug_object << val << "µs";
+    else
+        debug_object << val / 1000 << "ms";
+    return debug_object;
+}
diff --git a/qmc-example.pro b/qmc-example.pro
index 4dc3fed1..0c8bda22 100644
--- a/qmc-example.pro
+++ b/qmc-example.pro
@@ -5,3 +5,6 @@ windows { CONFIG += console }
 include(libqmatrixclient.pri)
 
 SOURCES += examples/qmc-example.cpp
+
+DISTFILES += \
+    .valgrind.qmc-example.supp
diff --git a/room.cpp b/room.cpp
index db36a713..25669889 100644
--- a/room.cpp
+++ b/room.cpp
@@ -24,6 +24,7 @@
 #include "jobs/generated/leaving.h"
 #include "jobs/generated/receipts.h"
 #include "jobs/generated/redaction.h"
+#include "jobs/generated/account-data.h"
 #include "jobs/setroomstatejob.h"
 #include "events/simplestateevents.h"
 #include "events/roomavatarevent.h"
@@ -35,6 +36,7 @@
 #include "jobs/roommessagesjob.h"
 #include "jobs/mediathumbnailjob.h"
 #include "jobs/downloadfilejob.h"
+#include "jobs/postreadmarkersjob.h"
 #include "avatar.h"
 #include "connection.h"
 #include "user.h"
@@ -44,6 +46,7 @@
 #include <QtCore/QElapsedTimer>
 #include <QtCore/QPointer>
 #include <QtCore/QDir>
+#include <QtCore/QTemporaryFile>
 #include <QtCore/QRegularExpression>
 
 #include <array>
@@ -52,15 +55,23 @@
 
 using namespace QMatrixClient;
 using namespace std::placeholders;
+#if !(defined __GLIBCXX__ && __GLIBCXX__ <= 20150123)
+using std::llround;
+#endif
 
 enum EventsPlacement : int { Older = -1, Newer = 1 };
 
+// A workaround for MSVC 2015 that fails with "error C2440: 'return':
+// cannot convert from 'initializer list' to 'QMatrixClient::FileTransferInfo'"
+#if (defined(_MSC_VER) && _MSC_VER < 1910) || (defined(__GNUC__) && __GNUC__ <= 4)
+#  define WORKAROUND_EXTENDED_INITIALIZER_LIST
+#endif
+
 class Room::Private
 {
     public:
         /** Map of user names to users. User names potentially duplicate, hence a multi-hashmap. */
         typedef QMultiHash<QString, User*> members_map_t;
-        typedef std::pair<rev_iter_t, rev_iter_t> rev_iter_pair_t;
 
         Private(Connection* c, QString id_, JoinState initialJoinState)
             : q(nullptr), connection(c), id(std::move(id_))
@@ -83,6 +94,7 @@ class Room::Private
         QString name;
         QString displayname;
         QString topic;
+        QString encryptionAlgorithm;
         Avatar avatar;
         JoinState joinState;
         int highlightCount = 0;
@@ -90,19 +102,20 @@ class Room::Private
         members_map_t membersMap;
         QList<User*> usersTyping;
         QList<User*> membersLeft;
-        bool unreadMessages = false;
+        int unreadMessages = 0;
         bool displayed = false;
         QString firstDisplayedEventId;
         QString lastDisplayedEventId;
         QHash<const User*, QString> lastReadEventIds;
-        QHash<QString, TagRecord> tags;
-        QHash<QString, QJsonObject> accountData;
+        QString serverReadMarker;
+        TagsMap tags;
+        QHash<QString, QVariantHash> accountData;
         QString prevBatch;
         QPointer<RoomMessagesJob> roomMessagesJob;
 
         struct FileTransferPrivateInfo
         {
-#if (defined(_MSC_VER) && _MSC_VER < 1910) || (defined(__GNUC__) && __GNUC__ <= 4)
+#ifdef WORKAROUND_EXTENDED_INITIALIZER_LIST
             FileTransferPrivateInfo() = default;
             FileTransferPrivateInfo(BaseJob* j, QString fileName)
                 : job(j), localFileInfo(fileName)
@@ -141,6 +154,7 @@ class Room::Private
         QHash<QString, FileTransferPrivateInfo> fileTransfers;
 
         const RoomMessageEvent* getEventWithFile(const QString& eventId) const;
+        QString fileNameToDownload(const RoomMessageEvent* event) const;
 
         //void inviteUser(User* u); // We might get it at some point in time.
         void insertMemberIntoMap(User* u);
@@ -176,10 +190,10 @@ class Room::Private
          * Removes events from the passed container that are already in the timeline
          */
         void dropDuplicateEvents(RoomEvents* events) const;
-        void checkUnreadMessages(timeline_iter_t from);
 
         void setLastReadEvent(User* u, const QString& eventId);
-        rev_iter_pair_t promoteReadMarker(User* u, rev_iter_t newMarker,
+        void updateUnreadCount(rev_iter_t from, rev_iter_t to);
+        void promoteReadMarker(User* u, rev_iter_t newMarker,
                                           bool force = false);
 
         void markMessagesAsRead(rev_iter_t upToMarker);
@@ -192,6 +206,14 @@ class Room::Private
          */
         void processRedaction(RoomEventPtr redactionEvent);
 
+        void broadcastTagUpdates()
+        {
+            connection->callApi<SetAccountDataPerRoomJob>(
+                    connection->userId(), id, TagEvent::typeId(),
+                        TagEvent(tags).toJson());
+            emit q->tagsChanged();
+        }
+
         QJsonObject toJson() const;
 
     private:
@@ -330,19 +352,62 @@ void Room::Private::setLastReadEvent(User* u, const QString& eventId)
     storedId = eventId;
     emit q->lastReadEventChanged(u);
     if (isLocalUser(u))
+    {
+        if (eventId != serverReadMarker)
+            connection->callApi<PostReadMarkersJob>(id, eventId);
         emit q->readMarkerMoved();
+    }
+}
+
+void Room::Private::updateUnreadCount(rev_iter_t from, rev_iter_t to)
+{
+    Q_ASSERT(from >= timeline.crbegin() && from <= timeline.crend());
+    Q_ASSERT(to >= from && to <= timeline.crend());
+
+    // Catch a special case when the last read event id refers to an event
+    // that has just arrived. In this case we should recalculate
+    // unreadMessages and might need to promote the read marker further
+    // over local-origin messages.
+    const auto readMarker = q->readMarker();
+    if (readMarker >= from && readMarker < to)
+    {
+        qCDebug(MAIN) << "Discovered last read event in room" << displayname;
+        promoteReadMarker(q->localUser(), readMarker, true);
+        return;
+    }
+
+    Q_ASSERT(to <= readMarker);
+
+    QElapsedTimer et; et.start();
+    const auto newUnreadMessages = count_if(from, to,
+            std::bind(&Room::Private::isEventNotable, this, _1));
+    if (et.nsecsElapsed() > 10000)
+        qCDebug(PROFILER) << "Counting gained unread messages took" << et;
+
+    if(newUnreadMessages > 0)
+    {
+        // See https://github.com/QMatrixClient/libqmatrixclient/wiki/unread_count
+        if (unreadMessages < 0)
+            unreadMessages = 0;
+
+        unreadMessages += newUnreadMessages;
+        qCDebug(MAIN) << "Room" << displayname << "has gained"
+            << newUnreadMessages << "unread message(s),"
+            << (q->readMarker() == timeline.crend() ?
+                    "in total at least" : "in total")
+            << unreadMessages << "unread message(s)";
+        emit q->unreadMessagesChanged(q);
+    }
 }
 
-Room::Private::rev_iter_pair_t
-Room::Private::promoteReadMarker(User* u, Room::rev_iter_t newMarker,
-                                 bool force)
+void Room::Private::promoteReadMarker(User* u, rev_iter_t newMarker, bool force)
 {
     Q_ASSERT_X(u, __FUNCTION__, "User* should not be nullptr");
     Q_ASSERT(newMarker >= timeline.crbegin() && newMarker <= timeline.crend());
 
     const auto prevMarker = q->readMarker(u);
     if (!force && prevMarker <= newMarker) // Remember, we deal with reverse iterators
-        return { prevMarker, prevMarker };
+        return;
 
     Q_ASSERT(newMarker < timeline.crend());
 
@@ -352,41 +417,49 @@ Room::Private::promoteReadMarker(User* u, Room::rev_iter_t newMarker,
           [=](const TimelineItem& ti) { return ti->senderId() != u->id(); });
 
     setLastReadEvent(u, (*(eagerMarker - 1))->id());
-    if (isLocalUser(u) && unreadMessages)
+    if (isLocalUser(u))
     {
-        auto stillUnreadMessagesCount = count_if(eagerMarker, timeline.cend(),
-                std::bind(&Room::Private::isEventNotable, this, _1));
-
-        if (stillUnreadMessagesCount == 0)
+        const auto oldUnreadCount = unreadMessages;
+        QElapsedTimer et; et.start();
+        unreadMessages = count_if(eagerMarker, timeline.cend(),
+                    std::bind(&Room::Private::isEventNotable, this, _1));
+        if (et.nsecsElapsed() > 10000)
+            qCDebug(PROFILER) << "Recounting unread messages took" << et;
+
+        // See https://github.com/QMatrixClient/libqmatrixclient/wiki/unread_count
+        if (unreadMessages == 0)
+            unreadMessages = -1;
+
+        if (force || unreadMessages != oldUnreadCount)
         {
-            unreadMessages = false;
-            qCDebug(MAIN) << "Room" << displayname << "has no more unread messages";
+            if (unreadMessages == -1)
+            {
+                qCDebug(MAIN) << "Room" << displayname
+                              << "has no more unread messages";
+            } else
+                qCDebug(MAIN) << "Room" << displayname << "still has"
+                              << unreadMessages << "unread message(s)";
             emit q->unreadMessagesChanged(q);
-        } else
-            qCDebug(MAIN) << "Room" << displayname << "still has"
-                          << stillUnreadMessagesCount << "unread message(s)";
+        }
     }
-
-    // Return newMarker, rather than eagerMarker, to save markMessagesAsRead()
-    // (that calls this method) from going back through knowingly-local messages.
-    return { prevMarker, newMarker };
 }
 
-void Room::Private::markMessagesAsRead(Room::rev_iter_t upToMarker)
+void Room::Private::markMessagesAsRead(rev_iter_t upToMarker)
 {
-    rev_iter_pair_t markers = promoteReadMarker(q->localUser(), upToMarker);
-    if (markers.first != markers.second)
+    const auto prevMarker = q->readMarker();
+    promoteReadMarker(q->localUser(), upToMarker);
+    if (prevMarker != upToMarker)
         qCDebug(MAIN) << "Marked messages as read until" << *q->readMarker();
 
     // We shouldn't send read receipts for the local user's own messages - so
     // search earlier messages for the latest message not from the local user
     // until the previous last-read message, whichever comes first.
-    for (; markers.second < markers.first; ++markers.second)
+    for (; upToMarker < prevMarker; ++upToMarker)
     {
-        if ((*markers.second)->senderId() != q->localUser()->id())
+        if ((*upToMarker)->senderId() != q->localUser()->id())
         {
-            connection->callApi<PostReceiptJob>(
-                id, "m.read", (*markers.second)->id());
+            connection->callApi<PostReceiptJob>(id, "m.read",
+                                                (*upToMarker)->id());
             break;
         }
     }
@@ -403,7 +476,12 @@ void Room::markAllMessagesAsRead()
         d->markMessagesAsRead(d->timeline.crbegin());
 }
 
-bool Room::hasUnreadMessages()
+bool Room::hasUnreadMessages() const
+{
+    return unreadCount() >= 0;
+}
+
+int Room::unreadCount() const
 {
     return d->unreadMessages;
 }
@@ -559,7 +637,7 @@ QStringList Room::tagNames() const
     return d->tags.keys();
 }
 
-const QHash<QString, TagRecord>& Room::tags() const
+TagsMap Room::tags() const
 {
     return d->tags;
 }
@@ -569,6 +647,32 @@ TagRecord Room::tag(const QString& name) const
     return d->tags.value(name);
 }
 
+void Room::addTag(const QString& name, const TagRecord& record)
+{
+    if (d->tags.contains(name))
+        return;
+
+    d->tags.insert(name, record);
+    d->broadcastTagUpdates();
+}
+
+void Room::removeTag(const QString& name)
+{
+    if (!d->tags.contains(name))
+        return;
+
+    d->tags.remove(name);
+    d->broadcastTagUpdates();
+}
+
+void Room::setTags(const TagsMap& newTags)
+{
+    if (newTags == d->tags)
+        return;
+    d->tags = newTags;
+    d->broadcastTagUpdates();
+}
+
 bool Room::isFavourite() const
 {
     return d->tags.contains(FavouriteTag);
@@ -579,6 +683,16 @@ bool Room::isLowPriority() const
     return d->tags.contains(LowPriorityTag);
 }
 
+bool Room::isDirectChat() const
+{
+    return connection()->isDirectChat(id());
+}
+
+QList<const User*> Room::directChatUsers() const
+{
+    return connection()->directChatUsers(this);
+}
+
 const RoomMessageEvent*
 Room::Private::getEventWithFile(const QString& eventId) const
 {
@@ -594,6 +708,39 @@ Room::Private::getEventWithFile(const QString& eventId) const
     return nullptr;
 }
 
+QString Room::Private::fileNameToDownload(const RoomMessageEvent* event) const
+{
+    Q_ASSERT(event->hasFileContent());
+    const auto* fileInfo = event->content()->fileInfo();
+    QString fileName;
+    if (!fileInfo->originalName.isEmpty())
+    {
+        fileName = QFileInfo(fileInfo->originalName).fileName();
+    }
+    else if (!event->plainBody().isEmpty())
+    {
+        // Having no better options, assume that the body has
+        // the original file URL or at least the file name.
+        QUrl u { event->plainBody() };
+        if (u.isValid())
+            fileName = QFileInfo(u.path()).fileName();
+    }
+    // Check the file name for sanity
+    if (fileName.isEmpty() || !QTemporaryFile(fileName).open())
+        return "file." % fileInfo->mimeType.preferredSuffix();
+
+    if (QSysInfo::productType() == "windows")
+    {
+        const auto& suffixes = fileInfo->mimeType.suffixes();
+        if (!suffixes.isEmpty() &&
+                std::none_of(suffixes.begin(), suffixes.end(),
+                    [&fileName] (const QString& s) {
+                        return fileName.endsWith(s); }))
+            return fileName % '.' % fileInfo->mimeType.preferredSuffix();
+    }
+    return fileName;
+}
+
 QUrl Room::urlToThumbnail(const QString& eventId)
 {
     if (auto* event = d->getEventWithFile(eventId))
@@ -623,13 +770,7 @@ QUrl Room::urlToDownload(const QString& eventId)
 QString Room::fileNameToDownload(const QString& eventId)
 {
     if (auto* event = d->getEventWithFile(eventId))
-    {
-        auto* fileInfo = event->content()->fileInfo();
-        Q_ASSERT(fileInfo != nullptr);
-        return !fileInfo->originalName.isEmpty() ? fileInfo->originalName :
-               !event->plainBody().isEmpty() ? event->plainBody() :
-               QString();
-    }
+        return d->fileNameToDownload(event);
     return {};
 }
 
@@ -647,13 +788,11 @@ FileTransferInfo Room::fileTransferInfo(const QString& id) const
     if (total > INT_MAX)
     {
         // JavaScript doesn't deal with 64-bit integers; scale down if necessary
-        progress = std::llround(double(progress) / total * INT_MAX);
+        progress = llround(double(progress) / total * INT_MAX);
         total = INT_MAX;
     }
 
-#if (defined(_MSC_VER) && _MSC_VER < 1910) || (defined(__GNUC__) && __GNUC__ <= 4)
-    // A workaround for MSVC 2015 that fails with "error C2440: 'return':
-    // cannot convert from 'initializer list' to 'QMatrixClient::FileTransferInfo'"
+#ifdef WORKAROUND_EXTENDED_INITIALIZER_LIST
     FileTransferInfo fti;
     fti.status = infoIt->status;
     fti.progress = int(progress);
@@ -745,6 +884,11 @@ int Room::timelineSize() const
     return int(d->timeline.size());
 }
 
+bool Room::usesEncryption() const
+{
+    return !d->encryptionAlgorithm.isEmpty();
+}
+
 void Room::Private::insertMemberIntoMap(User *u)
 {
     const auto userName = u->name(q);
@@ -870,13 +1014,16 @@ void Room::updateData(SyncRoomData&& data)
         d->prevBatch = data.timelinePrevBatch;
     setJoinState(data.joinState);
 
-    QElapsedTimer et;
+    QElapsedTimer et; et.start();
+    for (auto&& event: data.accountData)
+        processAccountDataEvent(move(event));
+
     if (!data.state.empty())
     {
-        et.start();
+        et.restart();
         processStateEvents(data.state);
         qCDebug(PROFILER) << "*** Room::processStateEvents(state):"
-            << et.elapsed() << "ms," << data.state.size() << "events";
+                          << data.state.size() << "event(s)," << et;
     }
     if (!data.timeline.empty())
     {
@@ -884,29 +1031,21 @@ void Room::updateData(SyncRoomData&& data)
         // State changes can arrive in a timeline event; so check those.
         processStateEvents(data.timeline);
         qCDebug(PROFILER) << "*** Room::processStateEvents(timeline):"
-            << et.elapsed() << "ms," << data.timeline.size() << "events";
+                          << data.timeline.size() << "event(s)," << et;
 
         et.restart();
         d->addNewMessageEvents(move(data.timeline));
-        qCDebug(PROFILER) << "*** Room::addNewMessageEvents():"
-                          << et.elapsed() << "ms";
-    }
-    if (!data.ephemeral.empty())
-    {
-        et.restart();
-        for( auto&& ephemeralEvent: data.ephemeral )
-            processEphemeralEvent(move(ephemeralEvent));
-        qCDebug(PROFILER) << "*** Room::processEphemeralEvents():"
-                          << et.elapsed() << "ms";
+        qCDebug(PROFILER) << "*** Room::addNewMessageEvents():" << et;
     }
+    for( auto&& ephemeralEvent: data.ephemeral )
+        processEphemeralEvent(move(ephemeralEvent));
 
-    if (!data.accountData.empty())
+    // See https://github.com/QMatrixClient/libqmatrixclient/wiki/unread_count
+    if (data.unreadCount != -2 && data.unreadCount != d->unreadMessages)
     {
-        et.restart();
-        for (auto&& event: data.accountData)
-            processAccountDataEvent(move(event));
-        qCDebug(PROFILER) << "*** Room::processAccountData():"
-                          << et.elapsed() << "ms";
+        qCDebug(MAIN) << "Setting unread_count to" << data.unreadCount;
+        d->unreadMessages = data.unreadCount;
+        emit unreadMessagesChanged(this);
     }
 
     if( data.highlightCount != d->highlightCount )
@@ -933,6 +1072,11 @@ void Room::postMessage(const QString& plainText, MessageEventType type)
 
 void Room::postMessage(const RoomMessageEvent& event)
 {
+    if (usesEncryption())
+    {
+        qCCritical(MAIN) << "Room" << displayName()
+            << "enforces encryption; sending encrypted messages is not supported yet";
+    }
     connection()->callApi<SendEventJob>(id(), event);
 }
 
@@ -1030,53 +1174,48 @@ void Room::uploadFile(const QString& id, const QUrl& localFilename,
 
 void Room::downloadFile(const QString& eventId, const QUrl& localFilename)
 {
-    Q_ASSERT_X(localFilename.isEmpty() || localFilename.isLocalFile(),
-               __FUNCTION__, "localFilename should point at a local file");
-    auto evtIt = findInTimeline(eventId);
-    if (evtIt == timelineEdge() ||
-            evtIt->event()->type() != EventType::RoomMessage)
+    auto ongoingTransfer = d->fileTransfers.find(eventId);
+    if (ongoingTransfer != d->fileTransfers.end() &&
+            ongoingTransfer->status == FileTransferInfo::Started)
     {
-        qCritical() << "Cannot download a file from event" << eventId
-                    << "(there's no such message event in the local timeline)";
-        Q_ASSERT(false);
+        qCWarning(MAIN) << "Download for" << eventId
+                        << "already started; to restart, cancel it first";
         return;
     }
-    auto* event = static_cast<const RoomMessageEvent*>(evtIt->event());
-    if (!event->hasFileContent())
+
+    Q_ASSERT_X(localFilename.isEmpty() || localFilename.isLocalFile(),
+               __FUNCTION__, "localFilename should point at a local file");
+    const auto* event = d->getEventWithFile(eventId);
+    if (!event)
     {
-        qCritical() << eventId << "has no file content; nothing to download";
+        qCCritical(MAIN)
+            << eventId << "is not in the local timeline or has no file content";
         Q_ASSERT(false);
         return;
     }
-    auto* fileInfo = event->content()->fileInfo();
-    auto safeTempPrefix = eventId;
-    safeTempPrefix.replace(':', '_');
-    safeTempPrefix = QDir::tempPath() + '/' + safeTempPrefix + '#';
-    auto fileName = !localFilename.isEmpty() ? localFilename.toLocalFile() :
-        !fileInfo->originalName.isEmpty() ?
-            (safeTempPrefix + fileInfo->originalName) :
-        !event->plainBody().isEmpty() ? (safeTempPrefix + event->plainBody()) :
-        (safeTempPrefix + fileInfo->mimeType.preferredSuffix());
-    if (QSysInfo::productType() == "windows")
+    const auto fileUrl = event->content()->fileInfo()->url;
+    auto filePath = localFilename.toLocalFile();
+    if (filePath.isEmpty())
     {
-        const auto& suffixes = fileInfo->mimeType.suffixes();
-        if (!suffixes.isEmpty() &&
-                std::none_of(suffixes.begin(), suffixes.end(),
-                    [fileName] (const QString& s) { return fileName.endsWith(s); }))
-            fileName += '.' + fileInfo->mimeType.preferredSuffix();
+        // Build our own file path, starting with temp directory and eventId.
+        filePath = eventId;
+        filePath = QDir::tempPath() % '/' % filePath.replace(':', '_') %
+                '#' % d->fileNameToDownload(event);
     }
-    auto job = connection()->downloadFile(fileInfo->url, fileName);
+    auto job = connection()->downloadFile(fileUrl, filePath);
     if (isJobRunning(job))
     {
+        // If there was a previous transfer (completed or failed), remove it.
+        d->fileTransfers.remove(eventId);
         d->fileTransfers.insert(eventId, { job, job->targetFileName() });
         connect(job, &BaseJob::downloadProgress, this,
             [this,eventId] (qint64 received, qint64 total) {
                 d->fileTransfers[eventId].update(received, total);
                 emit fileTransferProgress(eventId, received, total);
             });
-        connect(job, &BaseJob::success, this, [this,eventId,fileInfo,job] {
+        connect(job, &BaseJob::success, this, [this,eventId,fileUrl,job] {
                 d->fileTransfers[eventId].status = FileTransferInfo::Completed;
-                emit fileTransferCompleted(eventId, fileInfo->url,
+                emit fileTransferCompleted(eventId, fileUrl,
                         QUrl::fromLocalFile(job->targetFileName()));
             });
         connect(job, &BaseJob::failure, this,
@@ -1234,50 +1373,38 @@ void Room::Private::addNewMessageEvents(RoomEvents&& events)
     if (!normalEvents.empty())
         emit q->aboutToAddNewMessages(normalEvents);
     const auto insertedSize = insertEvents(std::move(normalEvents), Newer);
+    const auto from = timeline.cend() - insertedSize;
     if (insertedSize > 0)
     {
         qCDebug(MAIN)
                 << "Room" << displayname << "received" << insertedSize
                 << "new events; the last event is now" << timeline.back();
-        q->onAddNewTimelineEvents(timeline.cend() - insertedSize);
+        q->onAddNewTimelineEvents(from);
     }
     for (auto&& r: redactions)
         processRedaction(move(r));
     if (insertedSize > 0)
     {
         emit q->addedMessages();
-        checkUnreadMessages(timeline.cend() - insertedSize);
-    }
 
-    Q_ASSERT(timeline.size() == timelineSize + insertedSize);
-}
-
-void Room::Private::checkUnreadMessages(timeline_iter_t from)
-{
-    Q_ASSERT(from < timeline.cend());
-    const auto newUnreadMessages = count_if(from, timeline.cend(),
-            std::bind(&Room::Private::isEventNotable, this, _1));
+        // The first event in the just-added batch (referred to by `from`)
+        // defines whose read marker can possibly be promoted any further over
+        // the same author's events newly arrived. 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.
+        auto firstWriter = q->user((*from)->senderId());
+        if (q->readMarker(firstWriter) != timeline.crend())
+        {
+            promoteReadMarker(firstWriter, rev_iter_t(from) - 1);
+            qCDebug(MAIN) << "Auto-promoted read marker for" << firstWriter->id()
+                          << "to" << *q->readMarker(firstWriter);
+        }
 
-    // The first event in the just-added batch (referred to by `from`)
-    // defines whose read marker can possibly be promoted any further over
-    // the same author's events newly arrived. 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.
-    auto firstWriter = q->user((*from)->senderId());
-    if (q->readMarker(firstWriter) != timeline.crend())
-    {
-        promoteReadMarker(firstWriter, q->findInTimeline((*from)->id()));
-        qCDebug(MAIN) << "Auto-promoted read marker for" << firstWriter->id()
-                      << "to" << *q->readMarker(firstWriter);
+        updateUnreadCount(timeline.crbegin(), rev_iter_t(from));
     }
 
-    if(!unreadMessages && newUnreadMessages > 0)
-    {
-        unreadMessages = true;
-        emit q->unreadMessagesChanged(q);
-        qCDebug(MAIN) << "Room" << displayname << "has unread messages";
-    }
+    Q_ASSERT(timeline.size() == timelineSize + insertedSize);
 }
 
 void Room::Private::addHistoricalMessageEvents(RoomEvents&& events)
@@ -1292,24 +1419,17 @@ void Room::Private::addHistoricalMessageEvents(RoomEvents&& events)
         return;
 
     emit q->aboutToAddHistoricalMessages(normalEvents);
-    const bool thereWasNoReadMarker = q->readMarker() == timeline.crend();
     const auto insertedSize = insertEvents(std::move(normalEvents), Older);
+    const auto from = timeline.crend() - insertedSize;
 
-    // Catch a special case when the last read event id refers to an event
-    // that was outside the loaded timeline and has just arrived. Depending on
-    // other messages next to the last read one, we might need to promote
-    // the read marker and update unreadMessages flag.
-    const auto curReadMarker = q->readMarker();
-    if (thereWasNoReadMarker && curReadMarker != timeline.crend())
-    {
-        qCDebug(MAIN) << "Discovered last read event in a historical batch";
-        promoteReadMarker(q->localUser(), curReadMarker, true);
-    }
     qCDebug(MAIN) << "Room" << displayname << "received" << insertedSize
                   << "past events; the oldest event is now" << timeline.front();
-    q->onAddHistoricalTimelineEvents(timeline.crend() - insertedSize);
+    q->onAddHistoricalTimelineEvents(from);
     emit q->addedMessages();
 
+    if (from <= q->readMarker())
+        updateUnreadCount(from, timeline.crend());
+
     Q_ASSERT(timeline.size() == timelineSize + insertedSize);
 }
 
@@ -1365,6 +1485,11 @@ void Room::processStateEvents(const RoomEvents& events)
                 auto memberEvent = static_cast<RoomMemberEvent*>(event);
                 auto u = user(memberEvent->userId());
                 u->processEvent(memberEvent, this);
+                if (u == localUser() && memberJoinState(u) == JoinState::Invite
+                        && memberEvent->isDirect())
+                    connection()->addToDirectChats(this,
+                                    user(memberEvent->senderId()));
+
                 if( memberEvent->membership() == MembershipType::Join )
                 {
                     if (memberJoinState(u) != JoinState::Join)
@@ -1395,6 +1520,14 @@ void Room::processStateEvents(const RoomEvents& events)
                 }
                 break;
             }
+            case EventType::RoomEncryption:
+            {
+                d->encryptionAlgorithm =
+                        static_cast<EncryptionEvent*>(event)->algorithm();
+                qCDebug(MAIN) << "Encryption switched on in" << displayName();
+                emit encryption();
+                break;
+            }
             default: /* Ignore events of other types */;
         }
     }
@@ -1406,6 +1539,7 @@ void Room::processStateEvents(const RoomEvents& events)
 
 void Room::processEphemeralEvent(EventPtr event)
 {
+    QElapsedTimer et; et.start();
     switch (event->type())
     {
         case EventType::Typing: {
@@ -1417,6 +1551,9 @@ void Room::processEphemeralEvent(EventPtr event)
                 if (memberJoinState(u) == JoinState::Join)
                     d->usersTyping.append(u);
             }
+            if (!typingEvent->users().isEmpty())
+                qCDebug(PROFILER) << "*** Room::processEphemeralEvent(typing):"
+                    << typingEvent->users().size() << "users," << et;
             emit typingChanged();
             break;
         }
@@ -1433,11 +1570,13 @@ void Room::processEphemeralEvent(EventPtr event)
                                            << "as read for"
                                            << p.receipts.size() << "users";
                 }
-                if (d->eventsIndex.contains(p.evtId))
+                const auto newMarker = findInTimeline(p.evtId);
+                if (newMarker != timelineEdge())
                 {
-                    const auto newMarker = findInTimeline(p.evtId);
                     for( const Receipt& r: p.receipts )
                     {
+                        if (r.userId == connection()->userId())
+                            continue; // FIXME, #185
                         auto u = user(r.userId);
                         if (memberJoinState(u) == JoinState::Join)
                             d->promoteReadMarker(u, newMarker);
@@ -1452,6 +1591,8 @@ void Room::processEphemeralEvent(EventPtr event)
                     // Otherwise, blindly store the event id for this user.
                     for( const Receipt& r: p.receipts )
                     {
+                        if (r.userId == connection()->userId())
+                            continue; // FIXME, #185
                         auto u = user(r.userId);
                         if (memberJoinState(u) == JoinState::Join &&
                                 readMarker(u) == timelineEdge())
@@ -1459,13 +1600,15 @@ void Room::processEphemeralEvent(EventPtr event)
                     }
                 }
             }
-            if (receiptEvent->unreadMessages())
-                d->unreadMessages = true;
+            if (!receiptEvent->eventsWithReceipts().isEmpty())
+                qCDebug(PROFILER) << "*** Room::processEphemeralEvent(receipts):"
+                    << receiptEvent->eventsWithReceipts().size()
+                    << "events with receipts," << et;
             break;
         }
         default:
             qCWarning(EPHEMERAL) << "Unexpected event type in 'ephemeral' batch:"
-                                 << event->type();
+                                 << event->jsonType();
     }
 }
 
@@ -1474,11 +1617,33 @@ void Room::processAccountDataEvent(EventPtr event)
     switch (event->type())
     {
         case EventType::Tag:
-            d->tags = static_cast<TagEvent*>(event.get())->tags();
+        {
+            auto newTags = static_cast<TagEvent*>(event.get())->tags();
+            if (newTags == d->tags)
+                break;
+            d->tags = newTags;
+            qCDebug(MAIN) << "Room" << id() << "is tagged with:"
+                          << tagNames().join(", ");
             emit tagsChanged();
             break;
+        }
+        case EventType::ReadMarker:
+        {
+            const auto* rmEvent = static_cast<ReadMarkerEvent*>(event.get());
+            const auto& readEventId = rmEvent->event_id();
+            qCDebug(MAIN) << "Server-side read marker at" << readEventId;
+            d->serverReadMarker = readEventId;
+            const auto newMarker = findInTimeline(readEventId);
+            if (newMarker != timelineEdge())
+                d->markMessagesAsRead(newMarker);
+            else {
+                d->setLastReadEvent(localUser(), readEventId);
+            }
+            break;
+        }
         default:
-            d->accountData[event->jsonType()] = event->contentJson();
+            d->accountData[event->jsonType()] =
+                    event->contentJson().toVariantHash();
     }
 }
 
@@ -1567,110 +1732,95 @@ void Room::Private::updateDisplayname()
         emit q->displaynameChanged(q);
 }
 
-template <typename T>
 void appendStateEvent(QJsonArray& events, const QString& type,
-                     const QString& name, const T& content)
+                      const QJsonObject& content, const QString& stateKey = {})
 {
-    if (content.isEmpty())
-        return;
+    if (!content.isEmpty() || !stateKey.isEmpty())
+        events.append(QJsonObject
+            { { QStringLiteral("type"), type }
+            , { QStringLiteral("content"), content }
+            , { QStringLiteral("state_key"), stateKey }
+            });
+}
 
-    QJsonObject contentObj;
-    contentObj.insert(name, content);
+#define ADD_STATE_EVENT(events, type, name, content) \
+    appendStateEvent((events), QStringLiteral(type), \
+                     {{ QStringLiteral(name), content }});
 
-    QJsonObject eventObj;
-    eventObj.insert("type", type);
-    eventObj.insert("content", contentObj);
-    eventObj.insert("state_key", {}); // Mandatory for state events
+void appendEvent(QJsonArray& events, const QString& type,
+                 const QJsonObject& content)
+{
+    if (!content.isEmpty())
+        events.append(QJsonObject
+            { { QStringLiteral("type"), type }
+            , { QStringLiteral("content"), content }
+            });
+}
 
-    events.append(eventObj);
+template <typename EvtT>
+void appendEvent(QJsonArray& events, const EvtT& event)
+{
+    appendEvent(events, EvtT::TypeId, event.toJson());
 }
 
 QJsonObject Room::Private::toJson() const
 {
+    QElapsedTimer et; et.start();
     QJsonObject result;
     {
         QJsonArray stateEvents;
 
-        appendStateEvent(stateEvents, "m.room.name", "name", name);
-        appendStateEvent(stateEvents, "m.room.topic", "topic", topic);
-        appendStateEvent(stateEvents, "m.room.avatar", "url",
-                         avatar.url().toString());
-        appendStateEvent(stateEvents, "m.room.aliases", "aliases",
-                         QJsonArray::fromStringList(aliases));
-        appendStateEvent(stateEvents, "m.room.canonical_alias", "alias",
-                         canonicalAlias);
+        ADD_STATE_EVENT(stateEvents, "m.room.name", "name", name);
+        ADD_STATE_EVENT(stateEvents, "m.room.topic", "topic", topic);
+        ADD_STATE_EVENT(stateEvents, "m.room.avatar", "url",
+                        avatar.url().toString());
+        ADD_STATE_EVENT(stateEvents, "m.room.aliases", "aliases",
+                        QJsonArray::fromStringList(aliases));
+        ADD_STATE_EVENT(stateEvents, "m.room.canonical_alias", "alias",
+                        canonicalAlias);
+        ADD_STATE_EVENT(stateEvents, "m.room.encryption", "algorithm",
+                        encryptionAlgorithm);
 
         for (const auto *m : membersMap)
-        {
-            QJsonObject content;
-            content.insert("membership", QStringLiteral("join"));
-            content.insert("displayname", m->name(q));
-            content.insert("avatar_url", m->avatarUrl(q).toString());
-
-            QJsonObject memberEvent;
-            memberEvent.insert("type", QStringLiteral("m.room.member"));
-            memberEvent.insert("state_key", m->id());
-            memberEvent.insert("content", content);
-            stateEvents.append(memberEvent);
-        }
-
-        QJsonObject roomStateObj;
-        roomStateObj.insert("events", stateEvents);
-
-        result.insert(
-            joinState == JoinState::Invite ? "invite_state" : "state",
-            roomStateObj);
+            appendStateEvent(stateEvents, QStringLiteral("m.room.member"),
+                { { QStringLiteral("membership"), QStringLiteral("join") }
+                , { QStringLiteral("displayname"), m->name(q) }
+                , { QStringLiteral("avatar_url"), m->avatarUrl(q).toString() }
+            }, m->id());
+
+        const auto stateObjName = joinState == JoinState::Invite ?
+                    QStringLiteral("invite_state") : QStringLiteral("state");
+        result.insert(stateObjName,
+            QJsonObject {{ QStringLiteral("events"), stateEvents }});
     }
 
-    if (!q->readMarkerEventId().isEmpty())
-    {
-        QJsonArray ephemeralEvents;
-        {
-            // Don't dump the timestamp because it's useless in the cache.
-            QJsonObject user;
-            user.insert(connection->userId(), {});
-
-            QJsonObject receipt;
-            receipt.insert("m.read", user);
-
-            QJsonObject lastReadEvent;
-            lastReadEvent.insert(q->readMarkerEventId(), receipt);
-            lastReadEvent.insert("x-qmatrixclient.unread_messages",
-                                 unreadMessages);
-
-            QJsonObject receiptsObj;
-            receiptsObj.insert("type", QStringLiteral("m.receipt"));
-            receiptsObj.insert("content", lastReadEvent);
-            ephemeralEvents.append(receiptsObj);
-        }
-
-        QJsonObject ephemeralObj;
-        ephemeralObj.insert("events", ephemeralEvents);
+    QJsonArray accountDataEvents;
+    if (!tags.empty())
+        appendEvent(accountDataEvents, TagEvent(tags));
 
-        result.insert("ephemeral", ephemeralObj);
-    }
+    if (!serverReadMarker.isEmpty())
+        appendEvent(accountDataEvents, ReadMarkerEvent(serverReadMarker));
 
+    if (!accountData.empty())
     {
-        QJsonObject accountDataObj;
-        if (!tags.empty())
-        {
-            QJsonObject tagsObj;
-            for (auto it = tags.begin(); it != tags.end(); ++it)
-                tagsObj.insert(it.key(), { {"order", it->order} });
-            if (!tagsObj.empty())
-                accountDataObj.insert("m.tag", tagsObj);
-        }
-        if (!accountDataObj.empty())
-            result.insert("account_data", accountDataObj);
+        for (auto it = accountData.begin(); it != accountData.end(); ++it)
+            appendEvent(accountDataEvents, it.key(),
+                        QJsonObject::fromVariantHash(it.value()));
     }
+    result.insert("account_data", QJsonObject {{ "events", accountDataEvents }});
 
     QJsonObject unreadNotificationsObj;
+
+    unreadNotificationsObj.insert(SyncRoomData::UnreadCountKey, unreadMessages);
     if (highlightCount > 0)
         unreadNotificationsObj.insert("highlight_count", highlightCount);
     if (notificationCount > 0)
         unreadNotificationsObj.insert("notification_count", notificationCount);
-    if (!unreadNotificationsObj.isEmpty())
-        result.insert("unread_notifications", unreadNotificationsObj);
+
+    result.insert("unread_notifications", unreadNotificationsObj);
+
+    if (et.elapsed() > 50)
+        qCDebug(PROFILER) << "Room::toJson() for" << displayname << "took" << et;
 
     return result;
 }
diff --git a/room.h b/room.h
index 8e27a608..bdef04ee 100644
--- a/room.h
+++ b/room.h
@@ -20,13 +20,9 @@
 
 #include "jobs/syncjob.h"
 #include "events/roommessageevent.h"
-#include "events/tagevent.h"
+#include "events/accountdataevents.h"
 #include "joinstate.h"
 
-#include <QtCore/QList>
-#include <QtCore/QStringList>
-#include <QtCore/QObject>
-#include <QtCore/QJsonObject>
 #include <QtGui/QPixmap>
 
 #include <memory>
@@ -107,6 +103,7 @@ namespace QMatrixClient
             Q_PROPERTY(QString topic READ topic NOTIFY topicChanged)
             Q_PROPERTY(QString avatarMediaId READ avatarMediaId NOTIFY avatarChanged STORED false)
             Q_PROPERTY(QUrl avatarUrl READ avatarUrl NOTIFY avatarChanged)
+            Q_PROPERTY(bool usesEncryption READ usesEncryption NOTIFY encryption)
 
             Q_PROPERTY(int timelineSize READ timelineSize NOTIFY addedMessages)
             Q_PROPERTY(QStringList memberNames READ memberNames NOTIFY memberListChanged)
@@ -117,6 +114,8 @@ namespace QMatrixClient
             Q_PROPERTY(QString lastDisplayedEventId READ lastDisplayedEventId WRITE setLastDisplayedEventId NOTIFY lastDisplayedEventChanged)
 
             Q_PROPERTY(QString readMarkerEventId READ readMarkerEventId WRITE markMessagesAsRead NOTIFY readMarkerMoved)
+            Q_PROPERTY(bool hasUnreadMessages READ hasUnreadMessages NOTIFY unreadMessagesChanged)
+            Q_PROPERTY(int unreadCount READ unreadCount NOTIFY unreadMessagesChanged)
             Q_PROPERTY(QStringList tagNames READ tagNames NOTIFY tagsChanged)
 
         public:
@@ -147,6 +146,7 @@ namespace QMatrixClient
             QStringList memberNames() const;
             int memberCount() const;
             int timelineSize() const;
+            bool usesEncryption() const;
 
             /**
              * Returns a square room avatar with the given size and requests it
@@ -233,7 +233,26 @@ namespace QMatrixClient
              */
             void markMessagesAsRead(QString uptoEventId);
 
-            Q_INVOKABLE bool hasUnreadMessages();
+            /** Check whether there are unread messages in the room */
+            bool hasUnreadMessages() const;
+
+            /** Get the number of unread messages in the room
+             * Depending on the read marker state, this call may return either
+             * a precise or an estimate number of unread events. Only "notable"
+             * events (non-redacted message events from users other than local)
+             * are counted.
+             *
+             * In a case when readMarker() == timelineEdge() (the local read
+             * marker is beyond the local timeline) only the bottom limit of
+             * the unread messages number can be estimated (and even that may
+             * be slightly off due to, e.g., redactions of events not loaded
+             * to the local timeline).
+             *
+             * If all messages are read, this function will return -1 (_not_ 0,
+             * as zero may mean "zero or more unread messages" in a situation
+             * when the read marker is outside the local timeline.
+             */
+            int unreadCount() const;
 
             Q_INVOKABLE int notificationCount() const;
             Q_INVOKABLE void resetNotificationCount();
@@ -241,9 +260,30 @@ namespace QMatrixClient
             Q_INVOKABLE void resetHighlightCount();
 
             QStringList tagNames() const;
-            const QHash<QString, TagRecord>& tags() const;
+            TagsMap tags() const;
             TagRecord tag(const QString& name) const;
 
+            /** Add a new tag to this room
+             * If this room already has this tag, nothing happens. If it's a new
+             * tag for the room, the respective tag record is added to the set
+             * of tags and the new set is sent to the server to update other
+             * clients.
+             */
+            void addTag(const QString& name, const TagRecord& record = {});
+
+            /** Remove a tag from the room */
+            void removeTag(const QString& name);
+
+            /** Overwrite the room's tags
+             * This completely replaces the existing room's tags with a set
+             * of new ones and updates the new set on the server. Unlike
+             * most other methods in Room, this one sends a signal about changes
+             * immediately, not waiting for confirmation from the server
+             * (because tags are saved in account data rather than in shared
+             * room state).
+             */
+            void setTags(const TagsMap& newTags);
+
             /** Check whether the list of tags has m.favourite */
             bool isFavourite() const;
             /** Check whether the list of tags has m.lowpriority */
@@ -252,6 +292,9 @@ namespace QMatrixClient
             /** Check whether this room is a direct chat */
             bool isDirectChat() const;
 
+            /** Get the list of users this room is a direct chat with */
+            QList<const User*> directChatUsers() const;
+
             Q_INVOKABLE QUrl urlToThumbnail(const QString& eventId);
             Q_INVOKABLE QUrl urlToDownload(const QString& eventId);
             Q_INVOKABLE QString fileNameToDownload(const QString& eventId);
@@ -319,6 +362,7 @@ namespace QMatrixClient
             void memberAboutToRename(User* user, QString newName);
             void memberRenamed(User* user);
             void memberListChanged();
+            void encryption();
 
             void joinStateChanged(JoinState oldState, JoinState newState);
             void typingChanged();
diff --git a/user.cpp b/user.cpp
index 308b217c..7a6dbc73 100644
--- a/user.cpp
+++ b/user.cpp
@@ -34,7 +34,6 @@
 #include <QtCore/QElapsedTimer>
 
 #include <functional>
-#include <unordered_set>
 
 using namespace QMatrixClient;
 using namespace std::placeholders;
@@ -43,25 +42,30 @@ using std::move;
 class User::Private
 {
     public:
-        static Avatar* makeAvatar(QUrl url);
+        static Avatar makeAvatar(QUrl url)
+        {
+            static const QIcon icon
+                { QIcon::fromTheme(QStringLiteral("user-available")) };
+            return Avatar(move(url), icon);
+        }
 
         Private(QString userId, Connection* connection)
             : userId(move(userId)), connection(connection)
         { }
-        ~Private()
-        {
-            for (auto a: otherAvatars)
-                delete a;
-        }
 
         QString userId;
         Connection* connection;
 
-        QString mostUsedName;
         QString bridged;
-        const QScopedPointer<Avatar> mostUsedAvatar { makeAvatar({}) };
+        QString mostUsedName;
         QMultiHash<QString, const Room*> otherNames;
-        QHash<QUrl, Avatar*> otherAvatars;
+        Avatar mostUsedAvatar { makeAvatar({}) };
+        std::vector<Avatar> otherAvatars;
+        auto otherAvatar(QUrl url)
+        {
+            return std::find_if(otherAvatars.begin(), otherAvatars.end(),
+                    [&url] (const auto& av) { return av.url() == url; });
+        }
         QMultiHash<QUrl, const Room*> avatarsToRooms;
 
         mutable int totalRooms = 0;
@@ -76,12 +80,6 @@ class User::Private
 
 };
 
-Avatar* User::Private::makeAvatar(QUrl url)
-{
-    static const QIcon icon
-        { QIcon::fromTheme(QStringLiteral("user-available")) };
-    return new Avatar(url, icon);
-}
 
 QString User::Private::nameForRoom(const Room* r, const QString& hint) const
 {
@@ -128,8 +126,7 @@ void User::Private::setNameForRoom(const Room* r, QString newName,
             mostUsedName = newName;
             otherNames.remove(newName);
             if (totalRooms > MIN_JOINED_ROOMS_TO_LOG)
-                qCDebug(PROFILER) << et.elapsed()
-                                  << "ms to switch the most used name";
+                qCDebug(PROFILER) << et << "to switch the most used name";
         }
         else
             otherNames.insert(newName, r);
@@ -139,32 +136,33 @@ void User::Private::setNameForRoom(const Room* r, QString newName,
 QUrl User::Private::avatarUrlForRoom(const Room* r, const QUrl& hint) const
 {
     // If the hint is accurate, this function is O(1) instead of O(n)
-    if (hint == mostUsedAvatar->url() || avatarsToRooms.contains(hint, r))
+    if (hint == mostUsedAvatar.url() || avatarsToRooms.contains(hint, r))
         return hint;
     auto it = std::find(avatarsToRooms.begin(), avatarsToRooms.end(), r);
-    return it == avatarsToRooms.end() ? mostUsedAvatar->url() : it.key();
+    return it == avatarsToRooms.end() ? mostUsedAvatar.url() : it.key();
 }
 
 void User::Private::setAvatarForRoom(const Room* r, const QUrl& newUrl,
                                      const QUrl& oldUrl)
 {
     Q_ASSERT(oldUrl != newUrl);
-    Q_ASSERT(oldUrl == mostUsedAvatar->url() ||
+    Q_ASSERT(oldUrl == mostUsedAvatar.url() ||
              avatarsToRooms.contains(oldUrl, r));
     if (totalRooms < 2)
     {
         Q_ASSERT_X(totalRooms > 0 && otherAvatars.empty(), __FUNCTION__,
                    "Internal structures inconsistency");
-        mostUsedAvatar->updateUrl(newUrl);
+        mostUsedAvatar.updateUrl(newUrl);
         return;
     }
     avatarsToRooms.remove(oldUrl, r);
     if (!avatarsToRooms.contains(oldUrl))
     {
-        delete otherAvatars.value(oldUrl);
-        otherAvatars.remove(oldUrl);
+        auto it = otherAvatar(oldUrl);
+        if (it != otherAvatars.end())
+            otherAvatars.erase(it);
     }
-    if (newUrl != mostUsedAvatar->url())
+    if (newUrl != mostUsedAvatar.url())
     {
         // Check if the new avatar is about to become most used.
         if (avatarsToRooms.count(newUrl) >= totalRooms - avatarsToRooms.size())
@@ -173,23 +171,23 @@ void User::Private::setAvatarForRoom(const Room* r, const QUrl& newUrl,
             if (totalRooms > MIN_JOINED_ROOMS_TO_LOG)
             {
                 qCDebug(MAIN) << "Switching the most used avatar of user" << userId
-                              << "from" << mostUsedAvatar->url().toDisplayString()
+                              << "from" << mostUsedAvatar.url().toDisplayString()
                               << "to" << newUrl.toDisplayString();
                 et.start();
             }
             avatarsToRooms.remove(newUrl);
-            auto* nextMostUsed = otherAvatars.take(newUrl);
-            std::swap(*mostUsedAvatar, *nextMostUsed);
-            otherAvatars.insert(nextMostUsed->url(), nextMostUsed);
+            auto nextMostUsedIt = otherAvatar(newUrl);
+            Q_ASSERT(nextMostUsedIt != otherAvatars.end());
+            std::swap(mostUsedAvatar, *nextMostUsedIt);
             for (const auto* r1: connection->roomMap())
-                if (avatarUrlForRoom(r1) == nextMostUsed->url())
-                    avatarsToRooms.insert(nextMostUsed->url(), r1);
+                if (avatarUrlForRoom(r1) == nextMostUsedIt->url())
+                    avatarsToRooms.insert(nextMostUsedIt->url(), r1);
 
             if (totalRooms > MIN_JOINED_ROOMS_TO_LOG)
-                qCDebug(PROFILER) << et.elapsed()
-                                  << "ms to switch the most used avatar";
+                qCDebug(PROFILER) << et << "to switch the most used avatar";
         } else {
-            otherAvatars.insert(newUrl, makeAvatar(newUrl));
+            if (otherAvatar(newUrl) == otherAvatars.end())
+                otherAvatars.emplace_back(makeAvatar(newUrl));
             avatarsToRooms.insert(newUrl, r);
         }
     }
@@ -243,7 +241,7 @@ void User::updateName(const QString& newName, const QString& oldName,
 void User::updateAvatarUrl(const QUrl& newUrl, const QUrl& oldUrl,
                            const Room* room)
 {
-    Q_ASSERT(oldUrl == d->mostUsedAvatar->url() ||
+    Q_ASSERT(oldUrl == d->mostUsedAvatar.url() ||
              d->avatarsToRooms.contains(oldUrl, room));
     if (newUrl != oldUrl)
     {
@@ -289,6 +287,12 @@ bool User::setAvatar(QIODevice* source)
                 std::bind(&Private::setAvatarOnServer, d.data(), _1, this));
 }
 
+void User::requestDirectChat()
+{
+    Q_ASSERT(d->connection);
+    d->connection->requestDirectChat(d->userId);
+}
+
 void User::Private::setAvatarOnServer(QString contentUri, User* q)
 {
     auto* j = connection->callApi<SetAvatarUrlJob>(userId, contentUri);
@@ -316,8 +320,8 @@ QString User::bridged() const
 
 const Avatar& User::avatarObject(const Room* room) const
 {
-    return *d->otherAvatars.value(d->avatarUrlForRoom(room),
-                                  d->mostUsedAvatar.data());
+    auto it = d->otherAvatar(d->avatarUrlForRoom(room));
+    return it != d->otherAvatars.end() ? *it : d->mostUsedAvatar;
 }
 
 QImage User::avatar(int dimension, const Room* room)
diff --git a/user.h b/user.h
index d19fa8f4..f76f9e0a 100644
--- a/user.h
+++ b/user.h
@@ -101,6 +101,7 @@ namespace QMatrixClient
             void rename(const QString& newName, const Room* r);
             bool setAvatar(const QString& fileName);
             bool setAvatar(QIODevice* source);
+            void requestDirectChat();
 
         signals:
             void nameAboutToChange(QString newName, QString oldName,