From ed8faccfe96e7c2d8fa16f93abde900680e05aac Mon Sep 17 00:00:00 2001

From: Bardia Daneshvar <realbardiax@gmail.com>

Date: Tue, 19 Jul 2016 15:50:27 +0430

Subject: [PATCH 1/4] Add support for secret chats on the DialogListModel

 component Clear cache when the history was cleared Many bugfix and

 improvements

(cherry picked from commit 32bdf326cb75d8621da0b54e91be47b5c562ec85)

---

 telegramcache.cpp               | 10 +++++++

 telegramcache.h                 |  2 ++

 telegramdialoglistmodel.cpp     | 66 ++++++++++++++++++++++++++++++++++++++++-

 telegramdialoglistmodel.h       | 12 ++++++++

 telegrammessagelistmodel.cpp    | 35 +++++++++++++++++-----

 telegramnotificationhandler.cpp |  2 +-

 telegramqml_macros.h            | 13 +-------

 telegramtools.cpp               | 13 ++++++++

 telegramtools.h                 |  2 ++

 9 files changed, 133 insertions(+), 22 deletions(-)

diff --git a/telegramcache.cpp b/telegramcache.cpp

index 43254eb..216bc85 100644

--- a/telegramcache.cpp

+++ b/telegramcache.cpp

@@ -897,6 +897,16 @@ void TelegramCache::updates(qint64 msgId, const UpdatesType &result)

     onUpdates(result);

 }

+void TelegramCache::updatesGetDifferenceAnswer(qint64 id, const QList<Message> &messages, const QList<SecretChatMessage> &secretChatMessages, const QList<Update> &otherUpdates, const QList<Chat> &chats, const QList<User> &users, const UpdatesState &state, bool isIntermediateState)

+{

+

+}

+

+void TelegramCache::updateSecretChatMessage(const SecretChatMessage &secretChatMessage, qint32 qts)

+{

+

+}

+

 void TelegramCache::loadFromPts(qint32 pts)

 {

     if(!p->telegram)

diff --git a/telegramcache.h b/telegramcache.h

index aa75724..dc97a92 100644

--- a/telegramcache.h

+++ b/telegramcache.h

@@ -109,6 +109,8 @@ private:

     void insertUpdate(const Update &update);

     void updates(qint64 msgId, const UpdatesType &result);

+    void updatesGetDifferenceAnswer(qint64 id, const QList<Message> &messages, const QList<class SecretChatMessage> &secretChatMessages, const QList<Update> &otherUpdates, const QList<Chat> &chats, const QList<User> &users, const UpdatesState &state, bool isIntermediateState);

+    void updateSecretChatMessage(const class SecretChatMessage &secretChatMessage, qint32 qts);

     void loadFromPts(qint32 pts);

diff --git a/telegramdialoglistmodel.cpp b/telegramdialoglistmodel.cpp

index be266fd..5e69b92 100644

--- a/telegramdialoglistmodel.cpp

+++ b/telegramdialoglistmodel.cpp

@@ -20,9 +20,10 @@

 class TelegramDialogListItem

 {

 public:

-    TelegramDialogListItem() {}

+    TelegramDialogListItem(): secretChat(0) {}

     virtual ~TelegramDialogListItem() {}

     QByteArray id;

+    SecretChat* secretChat;

     TelegramSharedPointer<DialogObject> dialog;

     TelegramSharedPointer<InputPeerObject> peer;

     TelegramSharedPointer<ChatObject> chat;

@@ -237,6 +238,13 @@ QVariant TelegramDialogListModel::data(const QModelIndex &index, int role) const

         if(item.user) result = QString("%1 %2").arg(item.user->firstName(), item.user->lastName()).trimmed();

         if(item.chat) result = item.chat->title();

         break;

+    case RoleIsSecretChat:

+        result = (item.secretChat? true : false);

+        break;

+    case RoleSecretChatState:

+        if(item.secretChat) result = static_cast<int>(item.secretChat->state());

+        else result = -1;

+        break;

     case RoleMessageDate:

         if(item.topMessage) result = convertDate(QDateTime::fromTime_t(item.topMessage->date()));

         else result = QString();

@@ -470,6 +478,8 @@ QHash<int, QByteArray> TelegramDialogListModel::roleNames() const

     result = new QHash<int, QByteArray>();

     result->insert(RoleName, "title");

+    result->insert(RoleIsSecretChat, "isSecretChat");

+    result->insert(RoleSecretChatState, "secretChatState");

     result->insert(RoleMessageDate, "messageDate");

     result->insert(RoleMessageUnread, "messageUnread");

     result->insert(RoleMessageOut, "messageOut");

@@ -593,6 +603,18 @@ void TelegramDialogListModel::getDialogsFromServer(const InputPeer &offset, int

     setRefreshing(true);

+//    static QTimer *timer = 0;

+//    if(!timer)

+//    {

+//        timer = new QTimer();

+//        connect(timer, &QTimer::timeout, [this, offsetId, offset, limit](){

+//            Telegram *tg = mEngine->telegram();

+//            tg->messagesGetDialogs(0, offsetId, offset, limit);

+//            qDebug() << "Done";

+//        });

+//        timer->start(5000);

+//    }

+

     Telegram *tg = mEngine->telegram();

     DEFINE_DIS;

     p->lastRequest = tg->messagesGetDialogs(0, offsetId, offset, limit, [this, items, limit, dis](TG_MESSAGES_GET_DIALOGS_CALLBACK) {

@@ -614,9 +636,12 @@ void TelegramDialogListModel::getDialogsFromServer(const InputPeer &offset, int

         const int count = 0;//result.dialogs().count();

         if(count == 0 || count < limit) {

             /*! finished !*/

+            QHash<QByteArray, TelegramDialogListItem> itemsBkp = p->items; // Just to prevent from deleting objects

             changed(*items);

             delete items;

+            getSecretChats();

             getContactsFromServer();

+            Q_UNUSED(itemsBkp)

         } else {

             /*! There are also another dialogs !*/

             getDialogsFromServer(lastInputPeer, limit, items);

@@ -624,6 +649,39 @@ void TelegramDialogListModel::getDialogsFromServer(const InputPeer &offset, int

     });

 }

+void TelegramDialogListModel::getSecretChats()

+{

+    if(!mEngine || !mEngine->telegram())

+        return;

+

+    Telegram *tg = mEngine->telegram();

+    Settings *settings = tg->settings();

+    TelegramSharedDataManager *tsdm = mEngine->sharedData();

+    UserFullObject *me = mEngine->our();

+    if(!settings || !tsdm || !me)

+        return;

+

+    QHash<QByteArray, TelegramDialogListItem> items = p->items;

+

+    QList<SecretChat*> list = settings->secretChats();

+    Q_FOREACH(SecretChat *sc, list)

+    {

+        InputPeer peer = TelegramTools::secretChatInputPeer(sc);

+

+        qint32 toId = (me->user()->id()==sc->adminId()? sc->participantId() : sc->adminId());

+

+        TelegramDialogListItem item;

+        item.id = TelegramTools::identifier(sc);

+        item.peer = tsdm->insertInputPeer(peer);

+        item.user = tsdm->getUser( TelegramTools::identifier(Peer::typePeerUser, toId) );

+        item.secretChat = sc;

+

+        items[item.id] = item;

+    }

+

+    changed(items);

+}

+

 void TelegramDialogListModel::getContactsFromServer()

 {

     if(mEngine->state() != TelegramEngine::AuthLoggedIn)

@@ -701,6 +759,7 @@ InputPeer TelegramDialogListModel::processOnResult(const MessagesDialogs &result

         TelegramSharedPointer<InputPeerObject> ipeerPtr = tsdm->insertInputPeer(ipeer);

         (*items)[id].chat = chatPtr;

         (*items)[id].peer = ipeerPtr;

+

         connectChatSignals(id, chatPtr);

     }

@@ -718,6 +777,7 @@ InputPeer TelegramDialogListModel::processOnResult(const MessagesDialogs &result

         TelegramSharedPointer<InputPeerObject> ipeerPtr = tsdm->insertInputPeer(ipeer);

         (*items)[id].user = userPtr;

         (*items)[id].peer = ipeerPtr;

+

         connectUserSignals(id, userPtr);

     }

@@ -787,7 +847,11 @@ void TelegramDialogListModel::changed(const QHash<QByteArray, TelegramDialogList

             }

         }

+        const bool secretChat = itemNew.secretChat;

         const Dialog &dlg = itemNew.dialog->core();

+        if(secretChat && !(p->visibility & VisibilitySecretChats))

+            list.removeOne(id);

+        else

         if(dlg.peer().classType() == Peer::typePeerChannel && !(p->visibility & VisibilityChannels))

             list.removeOne(id);

         else

diff --git a/telegramdialoglistmodel.h b/telegramdialoglistmodel.h

index 7e6edf0..46911f7 100644

--- a/telegramdialoglistmodel.h

+++ b/telegramdialoglistmodel.h

@@ -18,6 +18,7 @@ class TELEGRAMQMLSHARED_EXPORT TelegramDialogListModel : public TelegramAbstract

     Q_ENUMS(VisibilityFlags)

     Q_ENUMS(SortFlag)

     Q_ENUMS(DataRoles)

+    Q_ENUMS(SecretChatState)

     Q_PROPERTY(int visibility READ visibility WRITE setVisibility NOTIFY visibilityChanged)

     Q_PROPERTY(QList<qint32> sortFlag READ sortFlag WRITE setSortFlag NOTIFY sortFlagChanged)

     Q_PROPERTY(QString filter READ filter WRITE setFilter NOTIFY filterChanged)

@@ -60,6 +61,9 @@ public:

         RolePeerItem,

         RolePeerHex,

+        RoleIsSecretChat,

+        RoleSecretChatState,

+

         RoleName,

         RoleMessageDate,

         RoleMessageUnread,

@@ -77,6 +81,13 @@ public:

         RoleCategory

     };

+    enum SecretChatState {

+        SecretChatStateInit = 0,

+        SecretChatStateRequested,

+        SecretChatStateAccepted,

+        SecretChatStateCancelled

+    };

+

     TelegramDialogListModel(QObject *parent = 0);

     ~TelegramDialogListModel();

@@ -141,6 +152,7 @@ protected:

 private:

     void getDialogsFromServer(const class InputPeer &offset, int limit, QHash<QByteArray, TelegramDialogListItem> *items = 0);

+    void getSecretChats();

     void getContactsFromServer();

     class InputPeer processOnResult(const class MessagesDialogs &result, QHash<QByteArray, TelegramDialogListItem> *items);

     void changed(const QHash<QByteArray, TelegramDialogListItem> &items);

diff --git a/telegrammessagelistmodel.cpp b/telegrammessagelistmodel.cpp

index e2fad51..e07d1d7 100644

--- a/telegrammessagelistmodel.cpp

+++ b/telegrammessagelistmodel.cpp

@@ -1032,7 +1032,25 @@ void TelegramMessageListModel::refresh()

             p->lastIsCache = true;

         }

-        getMessagesFromServer(0, 0, p->limit);

+        Telegram *tg = mEngine->telegram();

+        Settings *settings = tg->settings();

+        bool isSecretChat = false;

+        if(p->currentPeer && settings)

+        {

+            QList<SecretChat*> list = settings->secretChats();

+            Q_FOREACH(SecretChat *sc, list)

+            {

+                InputPeer peer = TelegramTools::secretChatInputPeer(sc);

+                if(peer == p->currentPeer->core())

+                {

+                    isSecretChat = true;

+                    break;

+                }

+            }

+        }

+

+        if(!isSecretChat)

+            getMessagesFromServer(0, 0, p->limit);

     }

 }

@@ -1078,15 +1096,16 @@ void TelegramMessageListModel::setHasBackMore(bool stt)

     p->hasBackMore = stt;

 }

-void TelegramMessageListModel::processOnResult(const MessagesMessages &result, bool appened)

+void TelegramMessageListModel::processOnResult(const MessagesMessages &result, bool append)

 {

-    if(p->lastIsCache)

-        clean();

-

     QHash<QByteArray, TelegramMessageListItem> items;

-    if(appened)

+    if(append && !p->lastIsCache)

         items = p->items;

+    TelegramCache *cache = (mEngine? mEngine->cache() : 0);

+    if(append && result.count()==0 && cache && p->currentPeer) /*! Clear cache if the dialog history cleared !*/

+        cache->deleteMessages(p->currentPeer->core());

+

     processOnResult(result, &items);

     changed(items);

     fetchReplies(result.messages());

@@ -1475,8 +1494,8 @@ void TelegramMessageListModel::changed(QHash<QByteArray, TelegramMessageListItem

     for( int i=0 ; i<p->list.count() ; i++ )

     {

-        const QByteArray &item = p->list.at(i);

-        if( list.contains(item) )

+        const QByteArray &key = p->list.at(i);

+        if( list.contains(key) )

             continue;

         beginRemoveRows(QModelIndex(), i, i);

diff --git a/telegramnotificationhandler.cpp b/telegramnotificationhandler.cpp

index 3976cb0..438fd70 100644

--- a/telegramnotificationhandler.cpp

+++ b/telegramnotificationhandler.cpp

@@ -105,7 +105,7 @@ void TelegramNotificationHandler::refreshUnreads()

         return;

     int unreadCount = 0;

-    int globalUnreadCount;

+    int globalUnreadCount = 0;

     QList<DialogObject*> dialogs = tsdm->dialogs();

     Q_FOREACH(DialogObject *dlg, dialogs)

     {

diff --git a/telegramqml_macros.h b/telegramqml_macros.h

index f1f5b66..5e9791e 100644

--- a/telegramqml_macros.h

+++ b/telegramqml_macros.h

@@ -3,18 +3,7 @@

 #include <QDebug>

-#define PROFILES_DB_CONNECTION "profiles_connection"

-#define PROFILES_DB_PATH ":/database/profiles.sqlite"

-

-#define USERDATA_DB_CONNECTION "userdata_connection"

-#define USERDATA_DB_PATH ":/database/userdata.sqlite"

-

-#define DATABASE_DB_CONNECTION "database_connection"

-#define DATABASE_DB_PATH ":/database/database.sqlite"

-

-#define CHECK_QUERY_ERROR(QUERY_OBJECT) \

-    if(QUERY_OBJECT.lastError().isValid()) \

-        qDebug() << __FUNCTION__ << QUERY_OBJECT.lastError().text();

+#define SECRETCHAT_CLASS_TYPE 0x74697f

 #endif // TELEGRAMQML_MACROS

diff --git a/telegramtools.cpp b/telegramtools.cpp

index 1f5b49e..31b4fb3 100644

--- a/telegramtools.cpp

+++ b/telegramtools.cpp

@@ -110,6 +110,11 @@ QByteArray TelegramTools::identifier(const Document &document)

     return res;

 }

+QByteArray TelegramTools::identifier(SecretChat *secretChat)

+{

+    return identifier(secretChatInputPeer(secretChat));

+}

+

 InputPeer TelegramTools::chatInputPeer(const Chat &chat)

 {

     InputPeer res;

@@ -168,6 +173,14 @@ InputPeer TelegramTools::peerInputPeer(const Peer &peer, qint64 accessHash)

     return res;

 }

+InputPeer TelegramTools::secretChatInputPeer(SecretChat *secretChat)

+{

+    InputPeer inputPeer(InputPeer::typeInputPeerChat);

+    inputPeer.setChatId(secretChat->chatId());

+    inputPeer.setAccessHash(secretChat->accessHash());

+    return inputPeer;

+}

+

 Peer TelegramTools::chatPeer(const Chat &chat)

 {

     Peer peer;

diff --git a/telegramtools.h b/telegramtools.h

index 3b6f45e..cdee056 100644

--- a/telegramtools.h

+++ b/telegramtools.h

@@ -28,10 +28,12 @@ public:

     static QByteArray identifier(const ChatFull &chat);

     static QByteArray identifier(const StickerSet &stickerSet);

     static QByteArray identifier(const Document &document);

+    static QByteArray identifier(class SecretChat *secretChat);

     static class InputPeer chatInputPeer(const Chat &chat);

     static class InputPeer userInputPeer(const User &user);

     static class InputPeer peerInputPeer(const Peer &peer, qint64 accessHash);

+    static class InputPeer secretChatInputPeer(class SecretChat *secretChat);

     static class Peer chatPeer(const Chat &chat);

     static class Peer userPeer(const User &user);

-- 

2.9.2