backlogManager->requestBacklog(bufferId, -1, -1, _backlogCount);
}
}
+
+// ========================================
+// GLOBAL UNREAD BACKLOG REQUESTER
+// ========================================
+GlobalUnreadBacklogRequester::GlobalUnreadBacklogRequester(ClientBacklogManager *backlogManager)
+ : BacklogRequester(false, backlogManager)
+{
+ BacklogSettings backlogSettings;
+ _limit = backlogSettings.globalUnreadBacklogLimit();
+ _additional = backlogSettings.globalUnreadBacklogAdditional();
+}
+
+void GlobalUnreadBacklogRequester::requestBacklog() {
+ MsgId oldestUnreadMessage;
+ foreach(BufferId bufferId, allBufferIds()) {
+ MsgId msgId = Client::networkModel()->lastSeenMsgId(bufferId);
+ if(!oldestUnreadMessage.isValid() || oldestUnreadMessage > msgId)
+ oldestUnreadMessage = msgId;
+ }
+ backlogManager->emitMessagesRequested(QObject::tr("Requesting up to %1 of all unread backlog messages (plus additional %2)").arg(_limit).arg(_additional));
+ backlogManager->requestBacklogAll(oldestUnreadMessage, -1, _limit, _additional);
+}
+
+// ========================================
+// PER BUFFER UNREAD BACKLOG REQUESTER
+// ========================================
+PerBufferUnreadBacklogRequester::PerBufferUnreadBacklogRequester(ClientBacklogManager *backlogManager)
+ : BacklogRequester(true, backlogManager)
+{
+ BacklogSettings backlogSettings;
+ _limit = backlogSettings.perBufferUnreadBacklogLimit();
+ _additional = backlogSettings.perBufferUnreadBacklogAdditional();
+}
+
+void PerBufferUnreadBacklogRequester::requestBacklog() {
+ QList<BufferId> allBuffers = allBufferIds();
+ setWaitingBuffers(allBuffers);
+ backlogManager->emitMessagesRequested(QObject::tr("Requesting a total of up to %1 unread backlog messages for %2 buffers").arg((_limit + _additional) * allBuffers.count()).arg(allBuffers.count()));
+ foreach(BufferId bufferId, allBuffers) {
+ backlogManager->requestBacklog(bufferId, Client::networkModel()->lastSeenMsgId(bufferId), -1, _limit, _additional);
+ }
+}
int _backlogCount;
};
+// ========================================
+// GLOBAL UNREAD BACKLOG REQUESTER
+// ========================================
+class GlobalUnreadBacklogRequester : public BacklogRequester {
+public:
+ GlobalUnreadBacklogRequester(ClientBacklogManager *backlogManager);
+ virtual void requestBacklog();
+
+private:
+ int _limit;
+ int _additional;
+};
+
+// ========================================
+// PER BUFFER UNREAD BACKLOG REQUESTER
+// ========================================
+class PerBufferUnreadBacklogRequester : public BacklogRequester {
+public:
+ PerBufferUnreadBacklogRequester(ClientBacklogManager *backlogManager);
+ virtual void requestBacklog();
+
+private:
+ int _limit;
+ int _additional;
+};
#endif //BACKLOGREQUESTER_H
inline int fixedBacklogAmount() { return localValue("FixedBacklogAmount", 500).toInt(); }
inline void setFixedBacklogAmount(int amount) { return setLocalValue("FixedBacklogAmount", amount); }
+
+ inline int globalUnreadBacklogLimit() { return localValue("GlobalUnreadBacklogLimit", 5000).toInt(); }
+ inline void setGlobalUnreadBacklogLimit(int limit) { return setLocalValue("GlobalUnreadBacklogLimit", limit); }
+ inline int globalUnreadBacklogAdditional() { return localValue("GlobalUnreadBacklogAdditional", 100).toInt(); }
+ inline void setGlobalUnreadBacklogAdditional(int Additional) { return setLocalValue("GlobalUnreadBacklogAdditional", Additional); }
+
+ inline int perBufferUnreadBacklogLimit() { return localValue("PerBufferUnreadBacklogLimit", 200).toInt(); }
+ inline void setPerBufferUnreadBacklogLimit(int limit) { return setLocalValue("PerBufferUnreadBacklogLimit", limit); }
+ inline int perBufferUnreadBacklogAdditional() { return localValue("PerBufferUnreadBacklogAdditional", 50).toInt(); }
+ inline void setPerBufferUnreadBacklogAdditional(int Additional) { return setLocalValue("PerBufferUnreadBacklogAdditional", Additional); }
};
#endif //BACKLOGSETTINGS_H
{
}
-void ClientBacklogManager::receiveBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, QVariantList msgs) {
- Q_UNUSED(first)
- Q_UNUSED(last)
- Q_UNUSED(limit)
+void ClientBacklogManager::receiveBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional, QVariantList msgs) {
+ Q_UNUSED(first) Q_UNUSED(last) Q_UNUSED(limit) Q_UNUSED(additional)
if(msgs.isEmpty())
return;
if(!_requester->buffer(bufferId, msglist)) {
// this was the last part to buffer
stopBuffering();
+ reset();
}
} else {
dispatchMessages(msglist);
}
}
+void ClientBacklogManager::receiveBacklogAll(MsgId first, MsgId last, int limit, int additional, QVariantList msgs) {
+ Q_UNUSED(first) Q_UNUSED(last) Q_UNUSED(limit) Q_UNUSED(additional)
+
+ MessageList msglist;
+ foreach(QVariant v, msgs) {
+ Message msg = v.value<Message>();
+ msg.setFlags(msg.flags() | Message::Backlog);
+ msglist << msg;
+ }
+
+ dispatchMessages(msglist);
+ reset();
+}
+
void ClientBacklogManager::requestInitialBacklog() {
if(_requester) {
qWarning() << "ClientBacklogManager::requestInitialBacklog() called twice in the same session! (Backlog has already been requested)";
BacklogSettings settings;
switch(settings.requesterType()) {
case BacklogRequester::GlobalUnread:
+ _requester = new GlobalUnreadBacklogRequester(this);
case BacklogRequester::PerBufferUnread:
+ _requester = new PerBufferUnreadBacklogRequester(this);
case BacklogRequester::PerBufferFixed:
default:
_requester = new FixedBacklogRequester(this);
Q_ASSERT(_requester);
dispatchMessages(_requester->bufferedMessages(), true);
- reset();
}
bool ClientBacklogManager::isBuffering() {
void reset();
public slots:
- virtual void receiveBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, QVariantList msgs);
+ virtual void receiveBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional, QVariantList msgs);
+ virtual void receiveBacklogAll(MsgId first, MsgId last, int limit, int additional, QVariantList msgs);
void requestInitialBacklog();
signals:
#include "backlogmanager.h"
-QVariantList BacklogManager::requestBacklog(BufferId bufferId, MsgId first, MsgId last, int limit) {
- emit backlogRequested(bufferId, first, last, limit);
+QVariantList BacklogManager::requestBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional) {
+ emit backlogRequested(bufferId, first, last, limit, additional);
+ return QVariantList();
+}
+
+QVariantList BacklogManager::requestBacklogAll(MsgId first, MsgId last, int limit, int additional) {
+ emit backlogAllRequested(first, last, limit, additional);
return QVariantList();
}
inline virtual const QMetaObject *syncMetaObject() const { return &staticMetaObject; }
public slots:
- virtual QVariantList requestBacklog(BufferId bufferId, MsgId first = -1, MsgId last = -1, int limit = -1);
- inline virtual void receiveBacklog(BufferId, MsgId, MsgId, int, QVariantList) {};
+ virtual QVariantList requestBacklog(BufferId bufferId, MsgId first = -1, MsgId last = -1, int limit = -1, int additional = 0);
+ inline virtual void receiveBacklog(BufferId, MsgId, MsgId, int, int, QVariantList) {};
-signals:
- void backlogRequested(BufferId, MsgId, MsgId, int);
+ virtual QVariantList requestBacklogAll(MsgId first = -1, MsgId last = -1, int limit = -1, int additional = 0);
+ inline virtual void receiveBacklogAll(MsgId, MsgId, int, int, QVariantList) {};
+signals:
+ void backlogRequested(BufferId, MsgId, MsgId, int, int);
+ void backlogAllRequested(MsgId, MsgId, int, int);
};
#endif // BACKLOGMANAGER_H
SELECT messageid, bufferid, time, type, flags, sender, message
FROM backlog
JOIN sender ON backlog.senderid = sender.senderid
-WHERE backlog.bufferid IN (SELECT bufferid FROM buffer WHERE userid = :userid) AND backlog.messageid >= :firstmsg
-ORDER BY messageid DESC;
+WHERE backlog.bufferid IN (SELECT bufferid FROM buffer WHERE userid = :userid)
+ AND backlog.messageid >= :firstmsg
+ORDER BY messageid DESC
LIMIT :limit
return instance()->storage->requestMsgs(user, bufferId, first, last, limit);
}
- //! Request all unread messages for all buffers
- /** \param first Return messages with MsgId >= first
+ //! Request a certain number of messages across all buffers
+ /** \param first if != -1 return only messages with a MsgId >= first
+ * \param last if != -1 return only messages with a MsgId < last
* \param limit Max amount of messages
* \return The requested list of messages
*/
- static inline QList<Message> requestAllNewMsgs(UserId user, int first, int limit = -1) {
- return instance()->storage->requestAllNewMsgs(user, first, limit);
+ static inline QList<Message> requestAllMsgs(UserId user, MsgId first = -1, MsgId last = -1, int limit = -1) {
+ return instance()->storage->requestAllMsgs(user, first, last, limit);
}
//! Request a list of all buffers known to a user.
{
}
-QVariantList CoreBacklogManager::requestBacklog(BufferId bufferId, MsgId first, MsgId last, int limit) {
+QVariantList CoreBacklogManager::requestBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional) {
QVariantList backlog;
QList<Message> msgList;
msgList = Core::requestMsgs(coreSession()->user(), bufferId, first, last, limit);
backlog << qVariantFromValue(*msgIter);
msgIter++;
}
+
+ if(additional) {
+ if(first != -1) {
+ last = first;
+ } else {
+ last = -1;
+ if(!msgList.isEmpty()) {
+ if(msgList.first().msgId() < msgList.last().msgId())
+ last = msgList.first().msgId();
+ else
+ last = msgList.last().msgId();
+ }
+ }
+ msgList = Core::requestMsgs(coreSession()->user(), bufferId, -1, last, additional);
+ msgIter = msgList.constBegin();
+ msgListEnd = msgList.constEnd();
+ while(msgIter != msgListEnd) {
+ backlog << qVariantFromValue(*msgIter);
+ msgIter++;
+ }
+ }
+
+ return backlog;
+}
+
+QVariantList CoreBacklogManager::requestBacklogAll(MsgId first, MsgId last, int limit, int additional) {
+ qDebug() << "CoreBacklogManager::requestBacklogAll" << first << last << limit << additional;
+ QVariantList backlog;
+ QList<Message> msgList;
+ msgList = Core::requestAllMsgs(coreSession()->user(), first, last, limit);
+
+ QList<Message>::const_iterator msgIter = msgList.constBegin();
+ QList<Message>::const_iterator msgListEnd = msgList.constEnd();
+ while(msgIter != msgListEnd) {
+ backlog << qVariantFromValue(*msgIter);
+ msgIter++;
+ }
+
+ if(additional) {
+ if(first != -1) {
+ last = first;
+ } else {
+ last = -1;
+ if(!msgList.isEmpty()) {
+ if(msgList.first().msgId() < msgList.last().msgId())
+ last = msgList.first().msgId();
+ else
+ last = msgList.last().msgId();
+ }
+ }
+ msgList = Core::requestAllMsgs(coreSession()->user(), -1, last, additional);
+ msgIter = msgList.constBegin();
+ msgListEnd = msgList.constEnd();
+ while(msgIter != msgListEnd) {
+ backlog << qVariantFromValue(*msgIter);
+ msgIter++;
+ }
+ }
+
return backlog;
}
CoreSession *coreSession() { return _coreSession; }
public slots:
- virtual QVariantList requestBacklog(BufferId bufferId, MsgId first = -1, MsgId last = -1, int limit = -1);
+ virtual QVariantList requestBacklog(BufferId bufferId, MsgId first = -1, MsgId last = -1, int limit = -1, int additional = 0);
+ virtual QVariantList requestBacklogAll(MsgId first = -1, MsgId last = -1, int limit = -1, int additional = 0);
private:
CoreSession *_coreSession;
<file>./SQL/SQLite/11/select_connected_networks.sql</file>
<file>./SQL/SQLite/11/select_internaluser.sql</file>
<file>./SQL/SQLite/11/select_messages.sql</file>
+ <file>./SQL/SQLite/11/select_messagesAll.sql</file>
<file>./SQL/SQLite/11/select_messagesAllNew.sql</file>
<file>./SQL/SQLite/11/select_messagesNew.sql</file>
<file>./SQL/SQLite/11/select_networkExists.sql</file>
return messagelist;
}
-QList<Message> SqliteStorage::requestAllNewMsgs(UserId user, int first, int limit) {
+QList<Message> SqliteStorage::requestAllMsgs(UserId user, MsgId first, MsgId last, int limit) {
QList<Message> messagelist;
QHash<BufferId, BufferInfo> bufferInfoHash;
}
QSqlQuery query(logDb());
- query.prepare(queryString("select_messagesAllNew"));
+ if(last == -1) {
+ query.prepare(queryString("select_messagesAllNew"));
+ } else {
+ query.prepare(queryString("select_messagesAll"));
+ query.bindValue(":lastmsg", last.toInt());
+ }
query.bindValue(":userid", user.toInt());
- query.bindValue(":firstmsg", first);
+ query.bindValue(":firstmsg", first.toInt());
query.bindValue(":limit", limit);
safeExec(query);
watchQuery(query);
while(query.next()) {
- Message msg(QDateTime::fromTime_t(query.value(1).toInt()),
- bufferInfoHash[query.value(2).toInt()],
+ Message msg(QDateTime::fromTime_t(query.value(2).toInt()),
+ bufferInfoHash[query.value(1).toInt()],
(Message::Type)query.value(3).toUInt(),
query.value(6).toString(),
query.value(5).toString(),
virtual MsgId logMessage(Message msg);
virtual QList<Message> requestMsgs(UserId user, BufferId bufferId, MsgId first = -1, MsgId last = -1, int limit = -1);
- virtual QList<Message> requestAllNewMsgs(UserId user, int first, int limit = -1);
+ virtual QList<Message> requestAllMsgs(UserId user, MsgId first = -1, MsgId last = -1, int limit = -1);
protected:
inline virtual QString driverName() { return "QSQLITE"; }
*/
virtual QList<Message> requestMsgs(UserId user, BufferId bufferId, MsgId first = -1, MsgId last = -1, int limit = -1) = 0;
- //! Request all unread messages for all buffers
- /** \param first Return messages with MsgId >= first
+ //! Request a certain number of messages across all buffers
+ /** \param first if != -1 return only messages with a MsgId >= first
+ * \param last if != -1 return only messages with a MsgId < last
* \param limit Max amount of messages
* \return The requested list of messages
*/
- virtual QList<Message> requestAllNewMsgs(UserId user, int first, int limit = -1) = 0;
+ virtual QList<Message> requestAllMsgs(UserId user, MsgId first = -1, MsgId last = -1, int limit = -1) = 0;
signals:
//! Sent when a new BufferInfo is created, or an existing one changed somehow.