सेलफिश ओएस के लिए VKontakte क्लाइंट में लांग पोल सर्वर के साथ काम का कार्यान्वयन

परिचय

दुर्भाग्य से, अब भी, आधुनिक दुनिया में, पुश प्रौद्योगिकी के लाभों का लाभ उठाना हमेशा संभव नहीं होता है , और कभी-कभी आपको वर्कआर्ड को लागू करना पड़ता है, उदाहरण के लिए, लोंग पोल के रूप में, जो आपको पुश सूचनाओं के तंत्र का अनुकरण करने की अनुमति देता है। विशेष रूप से, सेलफ़िश ओएस के लिए VKontakte क्लाइंट को लागू करते समय ऐसी आवश्यकता उत्पन्न हुई।

यह आलेख लांग पोल VKontakte सर्वर के साथ बातचीत के सिद्धांतों पर चर्चा नहीं करेगा - इसमें बहुत विस्तृत दस्तावेज हैं , और बुनियादी उदाहरण पहले ही प्रकाशित किए जा चुके हैं । इसके बजाय, एक विशिष्ट मंच के लिए एक व्यावहारिक कार्यान्वयन पर विचार किया जाएगा।

यह समझा जाता है कि पाठक न केवल QML में , बल्कि C ++ में भी सेलफिश ओएस के विकास से परिचित है।

लंबी पोल ग्राहक

मुख्य क्लाइंट क्लास LongPoll क्लास है, जो लॉन्ग पोल सर्वर पर सवाल LongPoll है और अपनी प्रतिक्रियाएँ देता है।

getLongPollServer विधि, जिसका कार्य सर्वर से कनेक्शन खोलने के लिए जानकारी प्राप्त करना है, को आवेदन आरंभीकरण के दौरान कहा जाता है, जो आपको तुरंत उपयोगकर्ता अपडेट प्राप्त करने की अनुमति देता है:

 /** *       Long Poll  . */ void LongPoll::getLongPollServer() { QUrl url("https://api.vk.com/method/messages.getLongPollServer"); //    API QUrlQuery query; query.addQueryItem("access_token", _accessToken); //  Access Token query.addQueryItem("v", "5.53"); //    API url.setQuery(query); //       _manager->get(QNetworkRequest(url)); //  GET-    } 

यदि अनुरोध सफलतापूर्वक पूरा हो गया है, तो लोंग पोल सर्वर के साथ कनेक्शन की जानकारी को सहेजा जाता है और doLongPollRequest विधि का उपयोग करके कनेक्शन खोला जाता है:

 /* *      . * @:param: reply --    . */ void LongPoll::finished(QNetworkReply* reply) { QJsonDocument jDoc = QJsonDocument::fromJson(reply->readAll()); //    JSON if (_server.isNull() || _server.isEmpty()) { //      QJsonObject jObj = jDoc.object().value("response").toObject(); _server = jObj.value("server").toString(); //    _key = jObj.value("key").toString(); //    _ts = jObj.value("ts").toInt(); //     doLongPollRequest(); //    Long Poll  } else { // ... //     // ... } reply->deleteLater(); //     } 

doLongPollRequest लॉन्ग पोल विधि में, सर्वर से आवश्यक कनेक्शन पैरामीटर पास किए जाते हैं:

 /* *     Long Poll . */ void LongPoll::doLongPollRequest() { QUrl url("https://" + _server); //    QUrlQuery query; query.addQueryItem("act", "a_check"); //     query.addQueryItem("key", _key); //   query.addQueryItem("ts", QString("%1").arg(_ts)); //    query.addQueryItem("wait", "25"); //  25   query.addQueryItem("mode", "10"); //       url.setQuery(query); //       _manager->get(QNetworkRequest(url)); //  GET-  Long Poll  } 

यह ध्यान देने योग्य है कि mode फ़ील्ड का मूल्य, 10 के बराबर, अनुलग्नकों (2) प्राप्त करने के लिए विकल्प जोड़कर और घटनाओं के एक विस्तारित सेट (8) को वापस करके प्राप्त किया गया था।

कनेक्शन खोलने की प्रतिक्रिया के रूप में, सर्वर एक JSON देता है जिसमें नवीनतम घटनाएँ होती हैं। प्रतिक्रिया finished विधि में संसाधित होती है:

 /* *      . * @:param: reply --    . */ void LongPoll::finished(QNetworkReply* reply) { QJsonDocument jDoc = QJsonDocument::fromJson(reply->readAll()); //    JSON if (_server.isNull() || _server.isEmpty()) { // ... //    // ... } else { QJsonObject jObj = jDoc.object(); if (jObj.contains("failed")) { //       if (jObj.value("failed").toInt() == 1) { //    _ts = jObj.value("ts").toInt(); //      doLongPollRequest(); //    Long Poll  } else { _server.clear(); //    _key.clear(); //    _ts = 0; //     getLongPollServer(); //      } } else { //      _ts = jObj.value("ts").toInt(); //      parseLongPollUpdates(jObj.value("updates").toArray()); //     doLongPollRequest(); //    Long Poll  } } reply->deleteLater(); //     } 

प्रतिक्रिया में failed क्षेत्र चार मान ले सकता है, लेकिन उनमें से केवल एक, एक के बराबर, को लॉन्ग पोल सर्वर से कनेक्ट करने के लिए जानकारी के लिए बार-बार अनुरोध की आवश्यकता नहीं होती है। इस कारण से, शर्त को कोड में जोड़ा गया था।

 jObj.value("failed").toInt() == 1 

parseLongPollUpdates विधि उनके प्रकार की जाँच के साथ आने वाली सभी घटनाओं के लिए एक सरल चक्र है:

 enum LONGPOLL_EVENTS { NEW_MESSAGE = 4, //   INPUT_MESSAGES_READ = 6, //    OUTPUT_MESSAGES_READ = 7, //    USER_TYPES_IN_DIALOG = 61, //      USER_TYPES_IN_CHAT = 62, //      UNREAD_DIALOGS_CHANGED = 80, //     }; /* *   ,   Long Poll . * @:param: updates --    . */ void LongPoll::parseLongPollUpdates(const QJsonArray& updates) { for (auto value : updates) { //     QJsonArray update = value.toArray(); //    switch (update.at(0).toInt()) { //    case NEW_MESSAGE: emit gotNewMessage(update.at(1).toInt()); break; case INPUT_MESSAGES_READ: emit readMessages(update.at(1).toInt(), update.at(2).toInt(), false); break; case OUTPUT_MESSAGES_READ: emit readMessages(update.at(1).toInt(), update.at(2).toInt(), true); break; case USER_TYPES_IN_DIALOG: emit userTyping(update.at(1).toInt(), 0); break; case USER_TYPES_IN_CHAT: emit userTyping(update.at(1).toInt(), update.at(2).toInt()); break; case UNREAD_DIALOGS_CHANGED: emit unreadDialogsCounterUpdated(update.at(1).toInt()); break; default: break; } } } 

कोड दिखाता है कि प्रत्येक नए लॉन्ग पोल इवेंट के लिए, क्लाइंट एक सिग्नल भेजता है जिसे एप्लिकेशन के किसी अन्य भाग द्वारा संसाधित किया जाना चाहिए। संकेत तर्क संपूर्ण घटना वस्तु नहीं है, बल्कि केवल इसके आवश्यक अंग हैं। उदाहरण के लिए, gotNewMessage सिग्नल केवल एक नए संदेश के पहचानकर्ता को प्रसारित करता है, जिसके द्वारा इसकी पूर्ण सामग्री का अनुरोध किया जाता है :

 void VkSDK::_gotNewMessage(int id) { _messages->getById(id); } 

इस एकल-पंक्ति फ़ंक्शन के परिणामस्वरूप , VKontakte सर्वर से अनुरोध किया जाता है कि इस संदेश के ऑब्जेक्ट के आगे निर्माण के साथ इसके पहचानकर्ता द्वारा संदेश के बारे में पूरी जानकारी प्राप्त करें। निष्कर्ष में, उपयोगकर्ता इंटरफ़ेस के साथ एक संकेत भेजा जाता है, जो एक नए संदेश के बारे में डेटा प्रेषित करता है, जो अधिसूचना पैनल में प्रदर्शित होता है:

 import QtQuick 2.0 //      QML import Sailfish.Silica 1.0 //      Sailfish OS import org.nemomobile.notifications 1.0 //      ApplicationWindow //   { // ... //   // ... Notification { //     id: commonNotification //    category: "harbour-kat" //   remoteActions: [ //  -    { "name": "default", "service": "nothing", "path": "nothing", "iface": "nothing", "method": "nothing" } ] } Connections { //     target: vksdk //    SDK  onGotNewMessage: { //      commonNotification.summary = name //      commonNotification.previewSummary = name //     commonNotification.body = preview //      commonNotification.previewBody = preview //     commonNotification.close() //      commonNotification.publish() //    } } } 

संवाद इंटरफ़ेस

अब, लांग पोल सर्वर के साथ क्लाइंट इंटरैक्शन के सिद्धांतों और उपयोगकर्ता इंटरफ़ेस में प्राप्त जानकारी को स्थानांतरित करने के सिद्धांतों के आधार पर, हम एक खुले संवाद को अपडेट करने के एक उदाहरण पर विचार कर सकते हैं।

पहली चीज जो आपकी आंख को पकड़ती है वह है Connections घटक:

 Connections { //     target: vksdk //    SDK  onSavedPhoto: { //       attachmentsList += name + ","; //       attachmentsBusy.running = false; //     } onUserTyping: { //       var tempId = userId; //      if (chatId !== 0) { //    tempId = chatId; //  ,     } if (tempId === historyId) { //       typingLabel.visible = true //      } } } 

onUserTyping स्लॉट उपयोगकर्ता को संबंधित सूचना प्रदर्शित करके संदेश के वार्ताकार द्वारा एक सेट की घटना को संसाधित करता है। यहां, पहले चरण में, कमरा पहचानकर्ता प्राप्त किया जाता है (कमरे का अर्थ है संवाद और चैट के लिए सामान्यीकृत शब्द), और दूसरे चरण में, एक अधिसूचना प्रदर्शित की जाती है यदि प्राप्त पहचानकर्ता और वर्तमान कमरे के पहचानकर्ता से मेल खाती है।

यह ध्यान देने योग्य है कि संदेशों के एक सेट के बारे में एक सूचना दस सेकंड के लिए प्रदर्शित की जाती है, अगर इस समय के दौरान एक नई घटना नहीं आई है जो फिर से अधिसूचना को सक्रिय करेगी। यह Timer घटक का उपयोग करके प्राप्त किया जाता है:

 Label { //     id: typingLabel //    anchors.bottom: newmessagerow.top //       width: parent.width //     horizontalAlignment: Text.AlignHCenter //      font.pixelSize: Theme.fontSizeExtraSmall //    color: Theme.secondaryColor //     text: qsTr("typing...") //    visible: false //      onVisibleChanged: if (visible) typingLabelTimer.running = true //     Timer { //    id: typingLabelTimer //    interval: 10000 //   --   onTriggered: typingLabel.visible = false //       } } 

onSavedPhoto स्लॉट संदेशों में छवि लोडिंग के अंत को संसाधित करने के लिए जिम्मेदार है, जो वर्तमान लेख के दायरे से परे है।

दूसरी चीज जो ब्याज की है वह संदेश सूची है:

 SilicaListView { //    id: messagesListView //    //        : anchors.left: parent.left anchors.right: parent.right //            : anchors.top: parent.top anchors.bottom: typingLabel.top verticalLayoutDirection: ListView.BottomToTop //      clip: true //   ,     model: vksdk.messagesModel //    delegate: MessageItem { //     //        : anchors.left: parent.left anchors.right: parent.right //     : userId: fromId //   date: datetime //    out_: out //    read_: read //    avatarSource: avatar //    bodyText: body //   photos: photosList //     videos: videosList //     audios: audiosList //     documents: documentsList //     links: linksList //     news: newsList //       geoTile: geoTileUrl //     geoMap: geoMapUrl //         fwdMessages: fwdMessagesList //    Component.onCompleted: { //      if (index === vksdk.messagesModel.size-1) { //       //      : vksdk.messages.getHistory(historyId, vksdk.messagesModel.size) } } } VerticalScrollDecorator {} //      } 

यहाँ, MessageItem घटक एकल संदेश प्रदर्शित करने के लिए जिम्मेदार है। इसका विचार इस लेख के दायरे से परे है।

संदेश स्वयं vksdk.messagesModel मॉडल से लिए गए हैं। यह मॉडल Message ऑब्जेक्ट्स की एक सूची है जो कि add , prepend , addProfile , readMessages और clear विधियों का उपयोग करके वास्तविक समय में अपडेट की जा सकती है:

 /* *    . */ void MessagesModel::clear() { beginRemoveRows(QModelIndex(), 0, _messages.size()); //     _messages.clear(); //   _profiles.clear(); //    endRemoveRows(); //     //    : QModelIndex index = createIndex(0, 0, nullptr); emit dataChanged(index, index); } /* *      . * @:param: message --    . */ void MessagesModel::add(Message* message) { //   : beginInsertRows(QModelIndex(), _messages.size(), _messages.size()); _messages.append(message); //    endInsertRows(); //    //    : QModelIndex index = createIndex(0, 0, static_cast<void *>(0)); emit dataChanged(index, index); } /* *       . * @:param: message --    . */ void MessagesModel::prepend(Message* message) { //        : if (_messages.isEmpty()) return; if (message->chat() && _messages.at(0)->chatId() != message->chatId()) return; if (!message->chat() && _messages.at(0)->userId() != message->userId()) return; beginInsertRows(QModelIndex(), 0, 0); //    _messages.insert(0, message); //   endInsertRows(); //    //    : QModelIndex index = createIndex(0, _messages.size(), nullptr); emit dataChanged(index, index); } /* *       . * @:param: profile --    . */ void MessagesModel::addProfile(Friend* profile) { //   ,       if (_profiles.contains(profile->id())) return; _profiles[profile->id()] = profile; //    : QModelIndex startIndex = createIndex(0, 0, nullptr); QModelIndex endIndex = createIndex(_messages.size(), 0, nullptr); emit dataChanged(startIndex, endIndex); } /* *    . * @:param: peerId --  . * @:param: localId --    . * @:param: out --     . */ void MessagesModel::readMessages(qint64 peerId, qint64 localId, bool out) { //        : if (_messages.isEmpty()) return; if (_messages.at(0)->chat() && _messages.at(0)->chatId() != peerId) return; if (!_messages.at(0)->chat() && _messages.at(0)->userId() != peerId) return; foreach (Message *message, _messages) { //       if (message->id() <= localId && message->isOut() == out) //    message->setReadState(true); //    } //    : QModelIndex startIndex = createIndex(0, 0, nullptr); QModelIndex endIndex = createIndex(_messages.size(), 0, nullptr); emit dataChanged(startIndex, endIndex); } 

सभी पांच तरीकों के लिए dataChanged सिग्नल का उपयोग है, जो इंगित करता है कि मॉडल में डेटा अपडेट किया गया है। इस सिग्नल को SilicaListView से संदेशों की वर्तमान स्थिति प्रदर्शित करने के लिए SilicaListView तत्वों को अपडेट किया SilicaListView । SilicaListView लिए संदेश जोड़ने के लिए, SilicaListView कॉल करके प्रदान SilicaListView जाती है और endInsertRows भेजती हैं जो क्रमशः rowsAboutToBeInserted और rowsInserted हैं। नतीजतन, उपयोगकर्ता संवाद में वास्तविक समय में नए संदेश और उनकी स्थिति देखेगा।

निष्कर्ष

इस लेख ने उदाहरण के रूप में वीके एप्लिकेशन का उपयोग करके सेलफिश ओएस के लिए विकसित करते समय लांग पोल सर्वर के साथ बातचीत की जांच की। क्लाइंट कार्यान्वयन की कुछ विशेषताएं और वास्तविक समय में उपयोगकर्ता इंटरफ़ेस को अपडेट करने का एक तरीका माना जाता था। इस आलेख में वर्णित एप्लिकेशन के लिए कोड GitHub पर उपलब्ध है।