diff --git a/src/ddpclient.cpp b/src/ddpclient.cpp
index 29da5611..2cda6a1f 100644
--- a/src/ddpclient.cpp
+++ b/src/ddpclient.cpp
@@ -1,294 +1,301 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "ddpclient.h"
 
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonObject>
+#include <QtCore/QJsonArray>
 
 #include <iostream>
 #include "ruqola.h"
 
 void process_test(QJsonDocument doc)
 {
     qDebug() << "Callback test:" << doc;
     qDebug() << "End callback";
 }
 
 void login_callback(QJsonDocument doc)
 {
     qDebug() << "LOGIN:" << doc;
     Ruqola::self()->setAuthToken(doc.object().value("token").toString());
     qDebug() << "End callback";
 }
 
 void DDPClient::resume_login_callback(QJsonDocument doc)
 {
     qDebug() << "LOGIN:" << doc;
     Ruqola::self()->setAuthToken(doc.object().value("token").toString());
     qDebug() << "End callback";
 }
 
 
 void empty_callback(QJsonDocument doc)
 {
     Q_UNUSED(doc);
 }
 
 DDPClient::DDPClient(const QString& url, QObject* parent)
  : QObject(parent),
   m_url(url),
   m_uid(1),
   m_loginJob(0),
   m_loginStatus(NotConnected),
   m_connected(false),
   m_attemptedPasswordLogin(false),
   m_attemptedTokenLogin(false)
 {
     m_webSocket.ignoreSslErrors();
     connect(&m_webSocket, &QWebSocket::connected, this, &DDPClient::onWSConnected);
     connect(&m_webSocket, &QWebSocket::textMessageReceived, this, &DDPClient::onTextMessageReceived);
     connect(&m_webSocket, &QWebSocket::disconnected, this, &DDPClient::WSclosed);
     connect(Ruqola::self(), &Ruqola::serverURLChanged, this, &DDPClient::onServerURLChange);    
     
     if (!url.isEmpty()) {
         m_webSocket.open(QUrl("wss://"+url+"/websocket"));
     }
     qDebug() << "Trying to connect to URL" << url;
     
 }
 
 DDPClient::~DDPClient()
 {
     m_webSocket.close();
 }
 
 void DDPClient::onServerURLChange()
 {
     if (Ruqola::self()->serverURL() != m_url || !m_webSocket.isValid()) {
         if (m_webSocket.isValid()) {
             m_webSocket.flush();
             m_webSocket.close();
         }
         m_url = Ruqola::self()->serverURL();
         m_webSocket.open(QUrl("wss://"+m_url+"/websocket"));
         connect(&m_webSocket, &QWebSocket::connected, this, &DDPClient::onWSConnected);
         qDebug() << "Reconnecting" << m_url; //<< m_webSocket.st;
     }
 }
 
 DDPClient::LoginStatus DDPClient::loginStatus() const
 {
     return m_loginStatus;
 }
 
 bool DDPClient::isConnected() const
 {
     return m_connected;
 }
 
 bool DDPClient::isLoggedIn() const
 {
     return m_loginStatus == LoggedIn;
 }
 
 unsigned int DDPClient::method(const QString& m, const QJsonDocument& params)
 {
     return method(m, params, empty_callback);
 }
 
 unsigned int DDPClient::method(const QString& method, const QJsonDocument& params, std::function<void (QJsonDocument)> callback)
 {
     QString json;
     if (params.isArray()){
         json = "{\"msg\":\"method\", \"method\": \"%1\", \"id\": \"%2\", \"params\": %3}";
     } else {
         json = "{\"msg\":\"method\", \"method\": \"%1\", \"id\": \"%2\", \"params\": [%3]}";
     }
     
     json = json.arg(method).arg(m_uid).arg(QString(params.toJson(QJsonDocument::Compact)));
     qDebug() << json.arg(method).arg(m_uid); //.arg(QString(params.toJson(QJsonDocument::Indented)));
     
     qint64 bytes = m_webSocket.sendTextMessage(json.toUtf8());
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
         qDebug() << m_webSocket.isValid() << m_webSocket.error() << m_webSocket.requestUrl();
     } else {
         qDebug() << "Successfully sent " << json;
     }
 
     //callback(QJsonDocument::fromJson(json.toUtf8()));
     m_callbackHash[m_uid] = callback;
 
     m_uid++;
     return m_uid - 1 ;
 }
 
 void DDPClient::subscribe(const QString& collection, const QJsonDocument& params)
 {
     QString json("{\"msg\":\"sub\",\"id\": \"%1\",\"name\":\"%2\", \"params\": %3}");
     json = json.arg(m_uid).arg(collection).arg(QString(params.toJson(QJsonDocument::Compact)));
     qint64 bytes = m_webSocket.sendBinaryMessage(json.toUtf8());
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
     }
     
     m_uid++;
 }
 
 void DDPClient::onTextMessageReceived(QString message)
 {
     QJsonDocument response = QJsonDocument::fromJson(message.toUtf8());
     if (!response.isNull() && response.isObject()) {
 
         QJsonObject root = response.object();
 
         QString messageType = root.value("msg").toString();
 
         if (messageType == "updated") {
 
         } else if (messageType == "result") {
             
 //             qDebug() << "got a result" << root;
             unsigned id = root.value("id").toString().toInt();
             
             if (m_callbackHash.contains(id)) {
                 std::function<void (QJsonDocument)> callback = m_callbackHash.take(id);
                 callback( QJsonDocument(root.value("result").toObject()) );
             }
             emit result(id, QJsonDocument(root.value("result").toObject()));
             
             if (id == m_loginJob) {
                 if (root.value("error").toObject().value("error").toInt() == 403) {
                     qDebug() << "Wrong password or token expired";
                     
 //                     // Kill wrong credentials, so we don't try to use them again
 //                     if (!Ruqola::instance()->authToken().isEmpty()) {
 //                         Ruqola::instance()->setAuthToken(QString());
 //                     } else if (!Ruqola::instance()->password().isEmpty()) {
 //                         Ruqola::instance()->setPassword(QString());
 //                     }
 //                     setLoginStatus(DDPClient::LoginFailed);
                     
                     
                     login(); // Let's keep trying to log in
                 } else {
                     Ruqola::self()->setAuthToken(root.value("result").toObject().value("token").toString());
 
                     setLoginStatus(DDPClient::LoggedIn);
                 }
 //                 emit loggedInChanged();
             }
             
         } else if (messageType == "connected") {
             qDebug() << "Connected";
             m_connected = true;
             emit connectedChanged();
             setLoginStatus(DDPClient::LoggingIn);
             login(); // Try to resume auth token login
             
             
         } else if (messageType == "error") {
             qDebug() << "ERROR!!" << message;
         } else if (messageType == "ping") {
             qDebug() << "Ping - Pong";
             m_webSocket.sendBinaryMessage("{\"msg\":\"pong\"}");
         } else if (messageType == "added"){
             qDebug() << "ADDING" <<root;
             emit added(root);
         } else if (messageType == "changed") {
             emit changed(root);
         } else if (messageType == "ready") {
             // do nothing
         }else {
             qDebug() << "received something unhandled:" << message;
         }
     }
     
 }
 
 void DDPClient::setLoginStatus(DDPClient::LoginStatus l)
 {
     qDebug() << "Setting login status to" << l;
     m_loginStatus = l;
     emit loginStatusChanged();
     
     // reset flags
     if (l == LoginFailed) {
         m_attemptedPasswordLogin = false;
         m_attemptedTokenLogin = false;
     }
 }
 
 void DDPClient::login()
 {
     if (!Ruqola::self()->password().isEmpty()) {
  
         // If we have a password and we couldn't log in, let's stop here
         if (m_attemptedPasswordLogin) {
             setLoginStatus(LoginFailed);
             return;
         }
         
         m_attemptedPasswordLogin = true;
         QString json = "{\"password\":\"%1\", \"user\": {\"username\":\"%2\"}}";
         json = json.arg(Ruqola::self()->password()).arg(Ruqola::self()->userName());
         m_loginJob = method("login", QJsonDocument::fromJson(json.toUtf8()));
         
     } else if (!Ruqola::self()->authToken().isEmpty() && !m_attemptedTokenLogin) {
         m_attemptedPasswordLogin = true;
         QString json = "{\"resume\":\"%1\"}";
         json = json.arg(Ruqola::self()->authToken());
         m_loginJob = method("login", QJsonDocument::fromJson(json.toUtf8()));
     } else {
         setLoginStatus(LoginFailed);
     }
 }
 
 void DDPClient::logOut()
 {
 //     setLoginStatus(NotConnected);
     m_webSocket.close();
 }
 
 void DDPClient::onWSConnected()
 {
     qDebug() << "Websocket connected at URL" << m_url;
     
-    QString json("{\"msg\":\"connect\", \"version\": \"1\", \"support\": [\"1\"]}");
-    
-    qint64 bytes = m_webSocket.sendTextMessage(json.toUtf8());
-    if (bytes < json.length()) {
+    QJsonArray supportedVersions;
+    supportedVersions.append("1");
+    QJsonObject protocol;
+    protocol["msg"] = "connect";
+    protocol["version"] = "1";
+    protocol["support"] = supportedVersions;
+//     QString json("{\"msg\":\"connect\", \"version\": \"1\", \"support\": [\"1\"]}");
+    QByteArray serialize = QJsonDocument(protocol).toJson(QJsonDocument::Compact);
+    qint64 bytes = m_webSocket.sendTextMessage(serialize);
+    if (bytes < serialize.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
     } else {
-        qDebug() << "Successfully sent " << json;
+        qDebug() << "Successfully sent " << serialize;
     }
 }
 
 void DDPClient::WSclosed()
 {
     qDebug() << "WebSocket CLOSED" << m_webSocket.closeReason() << m_webSocket.error() << m_webSocket.closeCode();
     setLoginStatus(NotConnected);
 //     m_connected = false;
 }
 
 
diff --git a/src/rocketchatbackend.cpp b/src/rocketchatbackend.cpp
index 8ad30a24..b6f6841e 100644
--- a/src/rocketchatbackend.cpp
+++ b/src/rocketchatbackend.cpp
@@ -1,253 +1,262 @@
 
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "rocketchatbackend.h"
 #include <QtCore>
 #include <QJsonObject>
 #include <QDebug>
 #include "ruqola.h"
 #include "ddpclient.h"
 
 void debug_callback(QJsonDocument doc)
 {
     qDebug() << "DEBUG:" << doc;
 }
 
 void process_backlog(QJsonDocument messages)
 {
     qDebug() << messages.object().value("messages").toArray().size();
     RocketChatBackend::processIncomingMessages(messages.object().value("messages").toArray());
 }
 
 
 void rooms_callback(QJsonDocument doc)
 {
     RoomModel *model = Ruqola::self()->roomModel();
     
     QJsonArray removed = doc.object().value("remove").toArray();
     QJsonArray updated = doc.object().value("update").toArray();
     
     for (int i = 0; i < updated.size(); i++) {
         QJsonObject room = updated.at(i).toObject();
     
         if (room.value("t").toString() != "d") {
 
             QString roomID = room.value("_id").toString();
             MessageModel *roomModel = Ruqola::self()->getModelForRoom(roomID);
             
             // let's be extra safe around crashes
             if (Ruqola::self()->loginStatus() == DDPClient::LoggedIn) {
                 Room r;
                 r.id = roomID;
                 r.name = room["name"].toString();
                 r.topic = room["topic"].toString();
                                 
                 qDebug() << "Adding room" << r.name << r.id << r.topic;
 
                 model->addRoom(r);
             }
             
             QJsonArray params;
             params.append(QJsonValue(roomID));
             Ruqola::self()->ddp()->subscribe("stream-room-messages", QJsonDocument(params));
 
             // Load history
             params.append(QJsonValue(QJsonValue::Null));
             params.append(QJsonValue(50)); // Max number of messages to load;
             QJsonObject dateObject;
             dateObject["$date"] = QJsonValue(roomModel->lastTimestamp());
             params.append(dateObject);
             Ruqola::self()->ddp()->method("loadHistory", QJsonDocument(params), process_backlog);
         }
     } 
 }
 
 void subs_callback(QJsonDocument doc)
 {
     RoomModel *model = Ruqola::self()->roomModel();
 
     QJsonArray removed = doc.object().value("remove").toArray();
     QJsonArray updated = doc.object().value("update").toArray();
     
     for (int i = 0; i < updated.size(); i++) {
         QJsonObject room = updated.at(i).toObject();
     
         if (room.value("t").toString() != "d") {
 
             QString roomID = room.value("rid").toString();
             MessageModel *roomModel = Ruqola::self()->getModelForRoom(roomID);
             
             // let's be extra safe around crashes
             if (Ruqola::self()->loginStatus() == DDPClient::LoggedIn) {
                 Room r;
                 r.id = roomID;
                 r.name = room["name"].toString();
                 r.topic = room["topic"].toString();
                                 
                 qDebug() << "Adding room" << r.name << r.id << r.topic;
                 
                 model->addRoom(r);
             }
             
-            QString params = QString("[\"%1\"]").arg(roomID);
-            Ruqola::self()->ddp()->subscribe("stream-room-messages", QJsonDocument::fromJson(params.toLatin1()));
-        
+            
+            QJsonArray params;
+            params.append(QJsonValue(roomID));
+            Ruqola::self()->ddp()->subscribe("stream-room-messages", QJsonDocument(params));
+
             // Load history
-            QByteArray json = "[\""+roomID.toLatin1() + "\", null, 50, {\"$date\": " +
-                               QString::number(roomModel->lastTimestamp()).toLatin1()+ "}]";
-            Ruqola::self()->ddp()->method("loadHistory", QJsonDocument::fromJson(json), process_backlog);
+            params.append(QJsonValue(QJsonValue::Null));
+            params.append(QJsonValue(50)); // Max number of messages to load;
+            QJsonObject dateObject;
+            dateObject["$date"] = QJsonValue(roomModel->lastTimestamp());
+            params.append(dateObject);
+            Ruqola::self()->ddp()->method("loadHistory", QJsonDocument(params), process_backlog);
         }
     } 
 }
 
 void RocketChatBackend::processIncomingMessages(QJsonArray messages)
 {
     foreach (const QJsonValue v, messages) {
         QJsonObject o = v.toObject();
         
         Message m;
         QString roomId = o.value("rid").toString();
         QString type = o.value("t").toString();
         m.username = o.value("u").toObject().value("username").toString();
         m.userID = o.value("u").toObject().value("_id").toString();
         m.message = o.value("msg").toString();
         m.messageID = o.value("_id").toString();
         m.roomID = roomId;    
         m.timestamp = (qint64)o.value("ts").toObject().value("$date").toDouble();
         
         if (!type.isEmpty()) {
             m.systemMessage = true;
             m.systemMessageType = type;
         } else {
             m.systemMessage = false;
         }
         
         Ruqola::self()->getModelForRoom(roomId)->addMessage(m);
 
 //       qDebug() << "RocketChatBackend::processIncomingMessages sending notification";
 
         //Send notifications only when user is logged in
         if ( Ruqola::self()->loginStatus() == DDPClient::LoggedIn) {
             QString userName = m.username;
             QString message = m.message;
             QString param = QString("%1 \n %2").arg(userName).arg(message);
             Ruqola::self()->notification()->setMessage(param);
         } else {
             qDebug() << m.username << " recieved message: " <<  m.message;
         }
     }
 }
 
 RocketChatBackend::RocketChatBackend(QObject* parent)
  : QObject(parent)
 {
         connect(Ruqola::self(), &Ruqola::loginStatusChanged, this, &RocketChatBackend::onLoginStatusChanged);
         connect(Ruqola::self(), &Ruqola::userIDChanged, this, &RocketChatBackend::onUserIDChanged);
         connect(Ruqola::self()->ddp(), &DDPClient::changed, this, &RocketChatBackend::onChanged);
         connect(Ruqola::self()->ddp(), &DDPClient::added, this, &RocketChatBackend::onAdded);
 }
 
 RocketChatBackend::~RocketChatBackend()
 {
 }
 
 void RocketChatBackend::onLoginStatusChanged()
 {
     if (Ruqola::self()->loginStatus() == DDPClient::LoggedIn) {
         
         qDebug() << "GETTING LIST OF ROOMS";
 //         Ruqola::self()->ddp()->method("subscriptions/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
-        Ruqola::self()->ddp()->method("rooms/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
+        QJsonObject params;
+        params["$date"] = QJsonValue(0); // get ALL rooms we've ever seen
+        
+        Ruqola::self()->ddp()->method("rooms/get", QJsonDocument(params), rooms_callback);
         
 //         Ruqola::self()->ddp()->subscribe("stream-room-messages", QJsonDocument::fromJson(params.toLatin1()));
 
     }
 }
 
 void RocketChatBackend::onLoggedIn()
 {
 //     if (Ruqola::self()->loginStatus() != DDPClient::LoggedIn) {
 //         qDebug() << "not yet logged in:" << Ruqola::self()->loginStatus();
 //         return;
 //     }
 
 //     // get list of rooms
 //     Ruqola::self()->ddp()->method("rooms/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
 }
 
 void RocketChatBackend::onAdded(QJsonObject object)
 {
     QString collection = object.value("collection").toString();
     
  //   qDebug() << "ROCKET BACK" << object << collection;
     
     if (collection == "stream-room-messages") {
         
     } else if (collection == "users") {
         
         if (object["username"].isNull()) {
             // it's us! get ID
             Ruqola::self()->setUserID(object["id"].toString());
         }
          qDebug() << "NEW USER ADDED: " << object.value("userName").toString();
         
     } else if (collection == "rooms") {
 
     }
     else if (collection == "stream-notify-user"){
 
     }
 }
 
 
 void RocketChatBackend::onChanged(QJsonObject object)
 {
     QString collection = object["collection"].toString();
 
 //    qDebug() << "ROCKET CHAT BACK onChanged" << object << collection;
     if (collection == "stream-room-messages") {
         QJsonObject fields = object.value("fields").toObject();
         QString roomId = fields.value("eventName").toString();
         QJsonArray contents = fields.value("args").toArray();
         RocketChatBackend::processIncomingMessages(contents);        
 
     }
     else if (collection == "users") {
         qDebug() << "USER CHANGED";
         
     }
     else if (collection == "rooms") {
 
     }
     else if (collection == "stream-notify-user"){
         qDebug() << "New notification";
     }
 }
 
 void RocketChatBackend::onUserIDChanged()
 {
     qDebug() << "subscribing to notification feed";
-    QString params = QString("[\"%1/%2\"]").arg(Ruqola::self()->userID()).arg(QString("notification"));
-    Ruqola::self()->ddp()->subscribe("stream-notify-user", QJsonDocument::fromJson(params.toLatin1()));
+    QJsonArray params;
+    params.append(QJsonValue(QString("%1/%2").arg(Ruqola::self()->userID()).arg(QString("notification"))));
+    Ruqola::self()->ddp()->subscribe("stream-notify-user", QJsonDocument(params));
 }