2018-01-04 10:22:53 +00:00
|
|
|
/*
|
|
|
|
This file is part of Telegram Desktop,
|
|
|
|
the official desktop application for the Telegram messaging service.
|
|
|
|
|
|
|
|
For license and copyright information please follow this link:
|
|
|
|
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
|
|
|
|
*/
|
|
|
|
#include "data/data_session.h"
|
|
|
|
|
|
|
|
#include "observer_peer.h"
|
2018-01-17 16:21:01 +00:00
|
|
|
#include "auth_session.h"
|
|
|
|
#include "apiwrap.h"
|
2019-03-25 11:49:57 +00:00
|
|
|
#include "mainwidget.h"
|
2019-01-21 13:42:21 +00:00
|
|
|
#include "core/application.h"
|
2019-04-10 11:26:15 +00:00
|
|
|
#include "core/crash_reports.h" // CrashReports::SetAnnotation
|
2018-10-23 09:44:42 +00:00
|
|
|
#include "ui/image/image.h"
|
2019-04-10 11:26:15 +00:00
|
|
|
#include "ui/image/image_source.h" // Images::LocalFileSource
|
2018-06-20 00:02:36 +00:00
|
|
|
#include "export/export_controller.h"
|
|
|
|
#include "export/view/export_view_panel_controller.h"
|
2018-04-09 17:48:29 +00:00
|
|
|
#include "window/notifications_manager.h"
|
2018-01-18 11:46:45 +00:00
|
|
|
#include "history/history.h"
|
2018-01-04 10:22:53 +00:00
|
|
|
#include "history/history_item_components.h"
|
2018-12-18 10:45:06 +00:00
|
|
|
#include "history/media/history_media.h"
|
2018-01-14 16:02:25 +00:00
|
|
|
#include "history/view/history_view_element.h"
|
2018-01-17 16:21:01 +00:00
|
|
|
#include "inline_bots/inline_bot_layout_item.h"
|
|
|
|
#include "storage/localstorage.h"
|
2018-08-27 11:35:58 +00:00
|
|
|
#include "storage/storage_encrypted_file.h"
|
2019-04-10 11:26:15 +00:00
|
|
|
#include "media/player/media_player_instance.h" // instance()->play()
|
|
|
|
#include "media/streaming/media_streaming_loader.h" // unique_ptr<Loader>
|
|
|
|
#include "media/streaming/media_streaming_reader.h" // make_shared<Reader>
|
2018-06-28 17:44:07 +00:00
|
|
|
#include "boxes/abstract_box.h"
|
2018-07-10 16:41:11 +00:00
|
|
|
#include "passport/passport_form_controller.h"
|
2019-01-03 12:36:01 +00:00
|
|
|
#include "window/themes/window_theme.h"
|
2019-06-19 15:09:03 +00:00
|
|
|
#include "lang/lang_keys.h" // tr::lng_deleted(tr::now) in user name
|
2018-01-17 16:21:01 +00:00
|
|
|
#include "data/data_media_types.h"
|
2019-04-15 11:54:03 +00:00
|
|
|
#include "data/data_folder.h"
|
2019-01-04 11:09:48 +00:00
|
|
|
#include "data/data_channel.h"
|
|
|
|
#include "data/data_chat.h"
|
|
|
|
#include "data/data_user.h"
|
|
|
|
#include "data/data_file_origin.h"
|
2018-01-17 16:21:01 +00:00
|
|
|
#include "data/data_photo.h"
|
|
|
|
#include "data/data_document.h"
|
|
|
|
#include "data/data_web_page.h"
|
|
|
|
#include "data/data_game.h"
|
2018-12-18 05:43:11 +00:00
|
|
|
#include "data/data_poll.h"
|
2019-04-10 11:26:15 +00:00
|
|
|
#include "styles/style_boxes.h" // st::backgroundSize
|
2018-01-04 10:22:53 +00:00
|
|
|
|
|
|
|
namespace Data {
|
2018-01-17 16:21:01 +00:00
|
|
|
namespace {
|
2018-01-04 10:22:53 +00:00
|
|
|
|
2019-02-19 06:57:53 +00:00
|
|
|
constexpr auto kMaxNotifyCheckDelay = 24 * 3600 * crl::time(1000);
|
2019-01-16 12:25:29 +00:00
|
|
|
constexpr auto kMaxWallpaperSize = 10 * 1024 * 1024;
|
2018-04-09 17:48:29 +00:00
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
using ViewElement = HistoryView::Element;
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
// s: box 100x100
|
|
|
|
// m: box 320x320
|
|
|
|
// x: box 800x800
|
|
|
|
// y: box 1280x1280
|
|
|
|
// w: box 2560x2560 // if loading this fix HistoryPhoto::updateFrom
|
|
|
|
// a: crop 160x160
|
|
|
|
// b: crop 320x320
|
|
|
|
// c: crop 640x640
|
|
|
|
// d: crop 1280x1280
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto InlineLevels = QByteArray::fromRawData("i", 1);
|
|
|
|
const auto SmallLevels = QByteArray::fromRawData("sambcxydwi", 10);
|
|
|
|
const auto ThumbnailLevels = QByteArray::fromRawData("mbcxasydwi", 10);
|
|
|
|
const auto LargeLevels = QByteArray::fromRawData("yxwmsdcbai", 10);
|
2018-01-17 16:21:01 +00:00
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
void CheckForSwitchInlineButton(not_null<HistoryItem*> item) {
|
|
|
|
if (item->out() || !item->hasSwitchInlineButton()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (const auto user = item->history()->peer->asUser()) {
|
|
|
|
if (!user->botInfo || !user->botInfo->inlineReturnPeerId) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (const auto markup = item->Get<HistoryMessageReplyMarkup>()) {
|
|
|
|
for (const auto &row : markup->rows) {
|
|
|
|
for (const auto &button : row) {
|
|
|
|
using ButtonType = HistoryMessageMarkupButton::Type;
|
|
|
|
if (button.type == ButtonType::SwitchInline) {
|
|
|
|
Notify::switchInlineBotButtonReceived(
|
|
|
|
QString::fromUtf8(button.data));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// We should get a full restriction in "{full}: {reason}" format and we
|
|
|
|
// need to find an "-all" tag in {full}, otherwise ignore this restriction.
|
2019-01-04 07:57:07 +00:00
|
|
|
QString ExtractUnavailableReason(const QString &restriction) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto fullEnd = restriction.indexOf(':');
|
|
|
|
if (fullEnd <= 0) {
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
// {full} is in "{type}-{tag}-{tag}-{tag}" format
|
|
|
|
// if we find "all" tag we return the restriction string
|
|
|
|
const auto typeTags = restriction.mid(0, fullEnd).split('-').mid(1);
|
2019-06-18 13:45:09 +00:00
|
|
|
#ifdef OS_MAC_STORE
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto restrictionApplies = typeTags.contains(qsl("all"))
|
|
|
|
|| typeTags.contains(qsl("ios"));
|
2019-06-18 13:45:09 +00:00
|
|
|
#elif defined OS_WIN_STORE // OS_MAC_STORE
|
|
|
|
const auto restrictionApplies = typeTags.contains(qsl("all"))
|
|
|
|
|| typeTags.contains(qsl("ms"));
|
|
|
|
#else
|
|
|
|
const auto restrictionApplies = typeTags.contains(qsl("all"));
|
|
|
|
#endif // OS_MAC_STORE || OS_WIN_STORE
|
2019-01-03 12:36:01 +00:00
|
|
|
if (restrictionApplies) {
|
|
|
|
return restriction.midRef(fullEnd + 1).trimmed().toString();
|
|
|
|
}
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2019-01-25 14:37:28 +00:00
|
|
|
MTPPhotoSize FindDocumentInlineThumbnail(const MTPDdocument &data) {
|
|
|
|
const auto &thumbs = data.vthumbs.v;
|
|
|
|
const auto i = ranges::find(
|
|
|
|
thumbs,
|
|
|
|
mtpc_photoStrippedSize,
|
|
|
|
&MTPPhotoSize::type);
|
|
|
|
return (i != thumbs.end())
|
|
|
|
? (*i)
|
|
|
|
: MTPPhotoSize(MTP_photoSizeEmpty(MTP_string("")));
|
|
|
|
}
|
|
|
|
|
|
|
|
MTPPhotoSize FindDocumentThumbnail(const MTPDdocument &data) {
|
2019-01-03 14:39:19 +00:00
|
|
|
const auto area = [](const MTPPhotoSize &size) {
|
2019-01-25 14:37:28 +00:00
|
|
|
static constexpr auto kInvalid = 0;
|
2019-01-03 14:39:19 +00:00
|
|
|
return size.match([](const MTPDphotoSizeEmpty &) {
|
|
|
|
return kInvalid;
|
|
|
|
}, [](const MTPDphotoStrippedSize &) {
|
|
|
|
return kInvalid;
|
|
|
|
}, [](const auto &data) {
|
2019-01-25 14:37:28 +00:00
|
|
|
return (data.vw.v * data.vh.v);
|
2019-01-03 14:39:19 +00:00
|
|
|
});
|
|
|
|
};
|
|
|
|
const auto &thumbs = data.vthumbs.v;
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto i = ranges::max_element(thumbs, std::less<>(), area);
|
|
|
|
return (i != thumbs.end() && area(*i) > 0)
|
2019-01-03 14:39:19 +00:00
|
|
|
? (*i)
|
|
|
|
: MTPPhotoSize(MTP_photoSizeEmpty(MTP_string("")));
|
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
rpl::producer<int> PinnedDialogsCountMaxValue() {
|
|
|
|
return rpl::single(
|
|
|
|
rpl::empty_value()
|
|
|
|
) | rpl::then(
|
|
|
|
Core::App().configUpdates()
|
|
|
|
) | rpl::map([=] {
|
|
|
|
return Global::PinnedDialogsCountMax();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-04-10 11:26:15 +00:00
|
|
|
bool PruneDestroyedAndSet(
|
|
|
|
base::flat_map<
|
|
|
|
not_null<DocumentData*>,
|
|
|
|
std::weak_ptr<::Media::Streaming::Reader>> &readers,
|
|
|
|
not_null<DocumentData*> document,
|
|
|
|
const std::shared_ptr<::Media::Streaming::Reader> &reader) {
|
|
|
|
auto result = false;
|
|
|
|
for (auto i = begin(readers); i != end(readers);) {
|
|
|
|
if (i->first == document) {
|
|
|
|
(i++)->second = reader;
|
|
|
|
result = true;
|
|
|
|
} else if (i->second.lock() != nullptr) {
|
|
|
|
++i;
|
|
|
|
} else {
|
|
|
|
i = readers.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
Session::Session(not_null<AuthSession*> session)
|
|
|
|
: _session(session)
|
2019-01-21 13:42:21 +00:00
|
|
|
, _cache(Core::App().databases().get(
|
2018-08-29 13:23:16 +00:00
|
|
|
Local::cachePath(),
|
|
|
|
Local::cacheSettings()))
|
2019-02-25 17:26:08 +00:00
|
|
|
, _bigFileCache(Core::App().databases().get(
|
|
|
|
Local::cacheBigFilePath(),
|
|
|
|
Local::cacheBigFileSettings()))
|
2019-04-22 14:22:39 +00:00
|
|
|
, _chatsList(PinnedDialogsCountMaxValue())
|
2019-04-16 14:05:56 +00:00
|
|
|
, _contactsList(Dialogs::SortMode::Name)
|
|
|
|
, _contactsNoChatsList(Dialogs::SortMode::Name)
|
2019-01-03 12:36:01 +00:00
|
|
|
, _selfDestructTimer([=] { checkSelfDestructItems(); })
|
2019-04-01 14:53:18 +00:00
|
|
|
, _sendActionsAnimation([=](crl::time now) {
|
|
|
|
return sendActionsAnimationCallback(now);
|
|
|
|
})
|
2018-04-09 17:48:29 +00:00
|
|
|
, _groups(this)
|
|
|
|
, _unmuteByFinishedTimer([=] { unmuteByFinished(); }) {
|
2018-08-29 13:23:16 +00:00
|
|
|
_cache->open(Local::cacheKey());
|
2019-02-25 17:26:08 +00:00
|
|
|
_bigFileCache->open(Local::cacheBigFileKey());
|
2018-08-27 11:35:58 +00:00
|
|
|
|
2018-02-08 09:20:14 +00:00
|
|
|
setupContactViewsViewer();
|
|
|
|
setupChannelLeavingViewer();
|
2019-04-16 14:05:56 +00:00
|
|
|
setupPeerNameViewer();
|
|
|
|
setupUserIsContactViewer();
|
2018-02-08 09:20:14 +00:00
|
|
|
}
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
void Session::clear() {
|
|
|
|
_sendActions.clear();
|
|
|
|
|
|
|
|
for (const auto &[peerId, history] : _histories) {
|
2019-04-08 09:16:45 +00:00
|
|
|
history->clear(History::ClearType::Unload);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
2019-04-25 12:45:15 +00:00
|
|
|
_dependentMessages.clear();
|
|
|
|
base::take(_messages);
|
|
|
|
base::take(_channelMessages);
|
|
|
|
_messageByRandomId.clear();
|
|
|
|
_sentMessagesData.clear();
|
|
|
|
cSetRecentInlineBots(RecentInlineBots());
|
|
|
|
cSetRecentStickers(RecentStickerPack());
|
|
|
|
App::clearMousedItems();
|
2019-01-03 12:36:01 +00:00
|
|
|
_histories.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<PeerData*> Session::peer(PeerId id) {
|
|
|
|
const auto i = _peers.find(id);
|
|
|
|
if (i != _peers.cend()) {
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
auto result = [&]() -> std::unique_ptr<PeerData> {
|
|
|
|
if (peerIsUser(id)) {
|
|
|
|
return std::make_unique<UserData>(this, id);
|
|
|
|
} else if (peerIsChat(id)) {
|
|
|
|
return std::make_unique<ChatData>(this, id);
|
|
|
|
} else if (peerIsChannel(id)) {
|
|
|
|
return std::make_unique<ChannelData>(this, id);
|
|
|
|
}
|
|
|
|
Unexpected("Peer id type.");
|
|
|
|
}();
|
|
|
|
|
|
|
|
result->input = MTPinputPeer(MTP_inputPeerEmpty());
|
|
|
|
return _peers.emplace(id, std::move(result)).first->second.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<UserData*> Session::user(UserId id) {
|
|
|
|
return peer(peerFromUser(id))->asUser();
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<ChatData*> Session::chat(ChatId id) {
|
|
|
|
return peer(peerFromChat(id))->asChat();
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<ChannelData*> Session::channel(ChannelId id) {
|
|
|
|
return peer(peerFromChannel(id))->asChannel();
|
|
|
|
}
|
|
|
|
|
|
|
|
PeerData *Session::peerLoaded(PeerId id) const {
|
|
|
|
const auto i = _peers.find(id);
|
|
|
|
if (i == end(_peers)) {
|
|
|
|
return nullptr;
|
|
|
|
} else if (i->second->loadedStatus != PeerData::FullLoaded) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
UserData *Session::userLoaded(UserId id) const {
|
|
|
|
if (const auto peer = peerLoaded(peerFromUser(id))) {
|
|
|
|
return peer->asUser();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
ChatData *Session::chatLoaded(ChatId id) const {
|
|
|
|
if (const auto peer = peerLoaded(peerFromChat(id))) {
|
|
|
|
return peer->asChat();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
ChannelData *Session::channelLoaded(ChannelId id) const {
|
|
|
|
if (const auto peer = peerLoaded(peerFromChannel(id))) {
|
|
|
|
return peer->asChannel();
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<UserData*> Session::processUser(const MTPUser &data) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto result = user(data.match([](const auto &data) {
|
|
|
|
return data.vid.v;
|
|
|
|
}));
|
|
|
|
auto minimal = false;
|
2019-04-01 14:53:18 +00:00
|
|
|
const MTPUserStatus *status = nullptr;
|
|
|
|
const MTPUserStatus emptyStatus = MTP_userStatusEmpty();
|
2019-01-03 12:36:01 +00:00
|
|
|
|
|
|
|
Notify::PeerUpdate update;
|
|
|
|
using UpdateFlag = Notify::PeerUpdate::Flag;
|
|
|
|
data.match([&](const MTPDuserEmpty &data) {
|
|
|
|
const auto canShareThisContact = result->canShareThisContactFast();
|
|
|
|
|
|
|
|
result->input = MTP_inputPeerUser(data.vid, MTP_long(0));
|
|
|
|
result->inputUser = MTP_inputUser(data.vid, MTP_long(0));
|
2019-06-19 15:09:03 +00:00
|
|
|
result->setName(tr::lng_deleted(tr::now), QString(), QString(), QString());
|
2019-01-03 12:36:01 +00:00
|
|
|
result->setPhoto(MTP_userProfilePhotoEmpty());
|
|
|
|
//result->setFlags(MTPDuser_ClientFlag::f_inaccessible | 0);
|
|
|
|
result->setFlags(MTPDuser::Flag::f_deleted);
|
|
|
|
if (!result->phone().isEmpty()) {
|
|
|
|
result->setPhone(QString());
|
|
|
|
update.flags |= UpdateFlag::UserPhoneChanged;
|
|
|
|
}
|
|
|
|
result->setBotInfoVersion(-1);
|
|
|
|
status = &emptyStatus;
|
2019-06-06 16:48:42 +00:00
|
|
|
result->setIsContact(false);
|
2019-01-03 12:36:01 +00:00
|
|
|
if (canShareThisContact != result->canShareThisContactFast()) {
|
|
|
|
update.flags |= UpdateFlag::UserCanShareContact;
|
|
|
|
}
|
|
|
|
}, [&](const MTPDuser &data) {
|
|
|
|
minimal = data.is_min();
|
|
|
|
|
|
|
|
const auto canShareThisContact = result->canShareThisContactFast();
|
|
|
|
if (minimal) {
|
|
|
|
const auto mask = 0
|
|
|
|
//| MTPDuser_ClientFlag::f_inaccessible
|
|
|
|
| MTPDuser::Flag::f_deleted;
|
|
|
|
result->setFlags((result->flags() & ~mask) | (data.vflags.v & mask));
|
|
|
|
} else {
|
|
|
|
result->setFlags(data.vflags.v);
|
|
|
|
if (data.is_self()) {
|
|
|
|
result->input = MTP_inputPeerSelf();
|
|
|
|
result->inputUser = MTP_inputUserSelf();
|
|
|
|
} else if (!data.has_access_hash()) {
|
|
|
|
result->input = MTP_inputPeerUser(data.vid, MTP_long(result->accessHash()));
|
|
|
|
result->inputUser = MTP_inputUser(data.vid, MTP_long(result->accessHash()));
|
|
|
|
} else {
|
|
|
|
result->input = MTP_inputPeerUser(data.vid, data.vaccess_hash);
|
|
|
|
result->inputUser = MTP_inputUser(data.vid, data.vaccess_hash);
|
|
|
|
}
|
2019-01-04 07:57:07 +00:00
|
|
|
result->setUnavailableReason(data.is_restricted()
|
|
|
|
? ExtractUnavailableReason(qs(data.vrestriction_reason))
|
|
|
|
: QString());
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
if (data.is_deleted()) {
|
|
|
|
if (!result->phone().isEmpty()) {
|
|
|
|
result->setPhone(QString());
|
|
|
|
update.flags |= UpdateFlag::UserPhoneChanged;
|
|
|
|
}
|
2019-06-19 15:09:03 +00:00
|
|
|
result->setName(tr::lng_deleted(tr::now), QString(), QString(), QString());
|
2019-01-03 12:36:01 +00:00
|
|
|
result->setPhoto(MTP_userProfilePhotoEmpty());
|
|
|
|
status = &emptyStatus;
|
|
|
|
} else {
|
|
|
|
// apply first_name and last_name from minimal user only if we don't have
|
|
|
|
// local values for first name and last name already, otherwise skip
|
|
|
|
bool noLocalName = result->firstName.isEmpty() && result->lastName.isEmpty();
|
|
|
|
QString fname = (!minimal || noLocalName) ? (data.has_first_name() ? TextUtilities::SingleLine(qs(data.vfirst_name)) : QString()) : result->firstName;
|
|
|
|
QString lname = (!minimal || noLocalName) ? (data.has_last_name() ? TextUtilities::SingleLine(qs(data.vlast_name)) : QString()) : result->lastName;
|
|
|
|
|
|
|
|
QString phone = minimal ? result->phone() : (data.has_phone() ? qs(data.vphone) : QString());
|
|
|
|
QString uname = minimal ? result->username : (data.has_username() ? TextUtilities::SingleLine(qs(data.vusername)) : QString());
|
|
|
|
|
|
|
|
const auto phoneChanged = (result->phone() != phone);
|
|
|
|
if (phoneChanged) {
|
|
|
|
result->setPhone(phone);
|
|
|
|
update.flags |= UpdateFlag::UserPhoneChanged;
|
|
|
|
}
|
|
|
|
const auto nameChanged = (result->firstName != fname)
|
|
|
|
|| (result->lastName != lname);
|
|
|
|
|
2019-03-12 10:36:33 +00:00
|
|
|
auto showPhone = !result->isServiceUser()
|
|
|
|
&& !data.is_support()
|
2019-01-03 12:36:01 +00:00
|
|
|
&& !data.is_self()
|
|
|
|
&& !data.is_contact()
|
|
|
|
&& !data.is_mutual_contact();
|
2019-03-12 10:36:33 +00:00
|
|
|
auto showPhoneChanged = !result->isServiceUser()
|
2019-01-03 12:36:01 +00:00
|
|
|
&& !data.is_self()
|
2019-06-06 16:48:42 +00:00
|
|
|
&& ((showPhone && result->isContact())
|
2019-01-03 12:36:01 +00:00
|
|
|
|| (!showPhone
|
2019-06-06 16:48:42 +00:00
|
|
|
&& !result->isContact()
|
|
|
|
&& !result->phone().isEmpty()));
|
2019-01-03 12:36:01 +00:00
|
|
|
if (minimal) {
|
|
|
|
showPhoneChanged = false;
|
2019-03-12 10:36:33 +00:00
|
|
|
showPhone = !result->isServiceUser()
|
2019-06-06 16:48:42 +00:00
|
|
|
&& !result->isContact()
|
|
|
|
&& !result->phone().isEmpty()
|
|
|
|
&& (result->id != _session->userPeerId());
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// see also Local::readPeer
|
|
|
|
|
|
|
|
const auto pname = (showPhoneChanged || phoneChanged || nameChanged)
|
|
|
|
? ((showPhone && !phone.isEmpty())
|
|
|
|
? App::formatPhone(phone)
|
|
|
|
: QString())
|
|
|
|
: result->nameOrPhone;
|
|
|
|
|
|
|
|
if (!minimal && data.is_self() && uname != result->username) {
|
|
|
|
CrashReports::SetAnnotation("Username", uname);
|
|
|
|
}
|
|
|
|
result->setName(fname, lname, pname, uname);
|
|
|
|
if (data.has_photo()) {
|
|
|
|
result->setPhoto(data.vphoto);
|
|
|
|
} else {
|
|
|
|
result->setPhoto(MTP_userProfilePhotoEmpty());
|
|
|
|
}
|
|
|
|
if (data.has_access_hash()) {
|
|
|
|
result->setAccessHash(data.vaccess_hash.v);
|
|
|
|
}
|
|
|
|
status = data.has_status() ? &data.vstatus : &emptyStatus;
|
|
|
|
}
|
|
|
|
if (!minimal) {
|
|
|
|
if (data.has_bot_info_version()) {
|
|
|
|
result->setBotInfoVersion(data.vbot_info_version.v);
|
|
|
|
result->botInfo->readsAllHistory = data.is_bot_chat_history();
|
|
|
|
if (result->botInfo->cantJoinGroups != data.is_bot_nochats()) {
|
|
|
|
result->botInfo->cantJoinGroups = data.is_bot_nochats();
|
|
|
|
update.flags |= UpdateFlag::BotCanAddToGroups;
|
|
|
|
}
|
|
|
|
result->botInfo->inlinePlaceholder = data.has_bot_inline_placeholder() ? '_' + qs(data.vbot_inline_placeholder) : QString();
|
|
|
|
} else {
|
|
|
|
result->setBotInfoVersion(-1);
|
|
|
|
}
|
2019-06-06 16:48:42 +00:00
|
|
|
result->setIsContact(data.is_contact()
|
|
|
|
|| data.is_mutual_contact());
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (canShareThisContact != result->canShareThisContactFast()) {
|
|
|
|
update.flags |= UpdateFlag::UserCanShareContact;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
if (minimal) {
|
|
|
|
if (result->loadedStatus == PeerData::NotLoaded) {
|
|
|
|
result->loadedStatus = PeerData::MinimalLoaded;
|
|
|
|
}
|
|
|
|
} else if (result->loadedStatus != PeerData::FullLoaded
|
|
|
|
&& (!result->isSelf() || !result->phone().isEmpty())) {
|
|
|
|
result->loadedStatus = PeerData::FullLoaded;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (status && !minimal) {
|
|
|
|
const auto oldOnlineTill = result->onlineTill;
|
|
|
|
const auto newOnlineTill = ApiWrap::OnlineTillFromStatus(
|
|
|
|
*status,
|
|
|
|
oldOnlineTill);
|
|
|
|
if (oldOnlineTill != newOnlineTill) {
|
|
|
|
result->onlineTill = newOnlineTill;
|
|
|
|
update.flags |= UpdateFlag::UserOnlineChanged;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (App::main()) {
|
|
|
|
if (update.flags) {
|
|
|
|
update.peer = result;
|
|
|
|
Notify::peerUpdatedDelayed(update);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<PeerData*> Session::processChat(const MTPChat &data) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto result = data.match([&](const MTPDchat &data) {
|
|
|
|
return peer(peerFromChat(data.vid.v));
|
|
|
|
}, [&](const MTPDchatForbidden &data) {
|
|
|
|
return peer(peerFromChat(data.vid.v));
|
|
|
|
}, [&](const MTPDchatEmpty &data) {
|
|
|
|
return peer(peerFromChat(data.vid.v));
|
|
|
|
}, [&](const MTPDchannel &data) {
|
|
|
|
return peer(peerFromChannel(data.vid.v));
|
|
|
|
}, [&](const MTPDchannelForbidden &data) {
|
|
|
|
return peer(peerFromChannel(data.vid.v));
|
|
|
|
});
|
|
|
|
auto minimal = false;
|
|
|
|
|
|
|
|
Notify::PeerUpdate update;
|
|
|
|
using UpdateFlag = Notify::PeerUpdate::Flag;
|
|
|
|
|
|
|
|
data.match([&](const MTPDchat &data) {
|
|
|
|
const auto chat = result->asChat();
|
2019-01-05 10:50:04 +00:00
|
|
|
|
|
|
|
const auto canAddMembers = chat->canAddMembers();
|
2019-01-13 08:03:34 +00:00
|
|
|
if (chat->version() < data.vversion.v) {
|
|
|
|
chat->setVersion(data.vversion.v);
|
2019-01-03 12:36:01 +00:00
|
|
|
chat->invalidateParticipants();
|
|
|
|
}
|
|
|
|
|
|
|
|
chat->input = MTP_inputPeerChat(data.vid);
|
|
|
|
chat->setName(qs(data.vtitle));
|
|
|
|
chat->setPhoto(data.vphoto);
|
|
|
|
chat->date = data.vdate.v;
|
|
|
|
|
2019-01-05 10:50:04 +00:00
|
|
|
chat->setAdminRights(data.has_admin_rights()
|
|
|
|
? data.vadmin_rights
|
|
|
|
: MTPChatAdminRights(MTP_chatAdminRights(MTP_flags(0))));
|
|
|
|
chat->setDefaultRestrictions(data.has_default_banned_rights()
|
|
|
|
? data.vdefault_banned_rights
|
2019-01-08 10:54:18 +00:00
|
|
|
: MTPChatBannedRights(
|
|
|
|
MTP_chatBannedRights(MTP_flags(0), MTP_int(0))));
|
2019-01-05 10:50:04 +00:00
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto &migratedTo = data.has_migrated_to()
|
|
|
|
? data.vmigrated_to
|
|
|
|
: MTPInputChannel(MTP_inputChannelEmpty());
|
2019-05-20 14:57:25 +00:00
|
|
|
migratedTo.match([&](const MTPDinputChannel & input) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto channel = this->channel(input.vchannel_id.v);
|
|
|
|
channel->addFlags(MTPDchannel::Flag::f_megagroup);
|
|
|
|
if (!channel->access) {
|
2019-01-14 06:34:51 +00:00
|
|
|
channel->input = MTP_inputPeerChannel(
|
|
|
|
input.vchannel_id,
|
|
|
|
input.vaccess_hash);
|
|
|
|
channel->inputChannel = migratedTo;
|
2019-01-03 12:36:01 +00:00
|
|
|
channel->access = input.vaccess_hash.v;
|
|
|
|
}
|
2019-01-14 06:34:51 +00:00
|
|
|
ApplyMigration(chat, channel);
|
2019-05-20 14:57:25 +00:00
|
|
|
}, [](const MTPDinputChannelFromMessage &) {
|
|
|
|
LOG(("API Error: migrated_to contains channel from message."));
|
2019-01-03 12:36:01 +00:00
|
|
|
}, [](const MTPDinputChannelEmpty &) {
|
|
|
|
});
|
|
|
|
|
|
|
|
chat->setFlags(data.vflags.v);
|
|
|
|
chat->count = data.vparticipants_count.v;
|
2019-01-05 10:50:04 +00:00
|
|
|
|
|
|
|
if (canAddMembers != chat->canAddMembers()) {
|
|
|
|
update.flags |= UpdateFlag::RightsChanged;
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
}, [&](const MTPDchatForbidden &data) {
|
|
|
|
const auto chat = result->asChat();
|
2019-01-05 10:50:04 +00:00
|
|
|
|
|
|
|
const auto canAddMembers = chat->canAddMembers();
|
2019-01-03 12:36:01 +00:00
|
|
|
|
|
|
|
chat->input = MTP_inputPeerChat(data.vid);
|
|
|
|
chat->setName(qs(data.vtitle));
|
|
|
|
chat->setPhoto(MTP_chatPhotoEmpty());
|
|
|
|
chat->date = 0;
|
|
|
|
chat->count = -1;
|
|
|
|
chat->invalidateParticipants();
|
|
|
|
chat->setFlags(MTPDchat_ClientFlag::f_forbidden | 0);
|
2019-01-05 10:50:04 +00:00
|
|
|
chat->setAdminRights(MTP_chatAdminRights(MTP_flags(0)));
|
|
|
|
chat->setDefaultRestrictions(
|
|
|
|
MTP_chatBannedRights(MTP_flags(0), MTP_int(0)));
|
|
|
|
|
|
|
|
if (canAddMembers != chat->canAddMembers()) {
|
|
|
|
update.flags |= UpdateFlag::RightsChanged;
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
}, [&](const MTPDchannel &data) {
|
|
|
|
const auto channel = result->asChannel();
|
|
|
|
|
|
|
|
minimal = data.is_min();
|
|
|
|
if (minimal) {
|
|
|
|
if (result->loadedStatus != PeerData::FullLoaded) {
|
|
|
|
LOG(("API Warning: not loaded minimal channel applied."));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const auto accessHash = data.has_access_hash()
|
|
|
|
? data.vaccess_hash
|
|
|
|
: MTP_long(0);
|
|
|
|
channel->input = MTP_inputPeerChannel(data.vid, accessHash);
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto wasInChannel = channel->amIn();
|
|
|
|
const auto canViewAdmins = channel->canViewAdmins();
|
|
|
|
const auto canViewMembers = channel->canViewMembers();
|
|
|
|
const auto canAddMembers = channel->canAddMembers();
|
|
|
|
|
|
|
|
if (data.has_participants_count()) {
|
|
|
|
channel->setMembersCount(data.vparticipants_count.v);
|
|
|
|
}
|
2019-01-08 10:54:18 +00:00
|
|
|
channel->setDefaultRestrictions(data.has_default_banned_rights()
|
|
|
|
? data.vdefault_banned_rights
|
|
|
|
: MTPChatBannedRights(
|
|
|
|
MTP_chatBannedRights(MTP_flags(0), MTP_int(0))));
|
2019-01-03 12:36:01 +00:00
|
|
|
if (minimal) {
|
|
|
|
auto mask = 0
|
|
|
|
| MTPDchannel::Flag::f_broadcast
|
|
|
|
| MTPDchannel::Flag::f_verified
|
|
|
|
| MTPDchannel::Flag::f_megagroup
|
|
|
|
| MTPDchannel_ClientFlag::f_forbidden;
|
|
|
|
channel->setFlags((channel->flags() & ~mask) | (data.vflags.v & mask));
|
|
|
|
} else {
|
|
|
|
if (data.has_admin_rights()) {
|
|
|
|
channel->setAdminRights(data.vadmin_rights);
|
|
|
|
} else if (channel->hasAdminRights()) {
|
2019-01-03 14:39:19 +00:00
|
|
|
channel->setAdminRights(MTP_chatAdminRights(MTP_flags(0)));
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
if (data.has_banned_rights()) {
|
2019-01-05 10:50:04 +00:00
|
|
|
channel->setRestrictions(data.vbanned_rights);
|
2019-01-03 12:36:01 +00:00
|
|
|
} else if (channel->hasRestrictions()) {
|
2019-01-05 10:50:04 +00:00
|
|
|
channel->setRestrictions(MTP_chatBannedRights(MTP_flags(0), MTP_int(0)));
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
channel->inputChannel = MTP_inputChannel(data.vid, data.vaccess_hash);
|
|
|
|
channel->access = data.vaccess_hash.v;
|
|
|
|
channel->date = data.vdate.v;
|
2019-01-13 08:03:34 +00:00
|
|
|
if (channel->version() < data.vversion.v) {
|
|
|
|
channel->setVersion(data.vversion.v);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
2019-01-04 07:57:07 +00:00
|
|
|
channel->setUnavailableReason(data.is_restricted()
|
|
|
|
? ExtractUnavailableReason(qs(data.vrestriction_reason))
|
|
|
|
: QString());
|
2019-01-03 12:36:01 +00:00
|
|
|
channel->setFlags(data.vflags.v);
|
|
|
|
//if (data.has_feed_id()) { // #feed
|
|
|
|
// channel->setFeed(feed(data.vfeed_id.v));
|
|
|
|
//} else {
|
|
|
|
// channel->clearFeed();
|
|
|
|
//}
|
|
|
|
}
|
|
|
|
|
|
|
|
QString uname = data.has_username() ? TextUtilities::SingleLine(qs(data.vusername)) : QString();
|
|
|
|
channel->setName(qs(data.vtitle), uname);
|
|
|
|
|
|
|
|
channel->setPhoto(data.vphoto);
|
|
|
|
|
|
|
|
if (wasInChannel != channel->amIn()) {
|
|
|
|
update.flags |= UpdateFlag::ChannelAmIn;
|
|
|
|
}
|
|
|
|
if (canViewAdmins != channel->canViewAdmins()
|
|
|
|
|| canViewMembers != channel->canViewMembers()
|
|
|
|
|| canAddMembers != channel->canAddMembers()) {
|
2019-01-05 10:50:04 +00:00
|
|
|
update.flags |= UpdateFlag::RightsChanged;
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
}, [&](const MTPDchannelForbidden &data) {
|
|
|
|
const auto channel = result->asChannel();
|
|
|
|
channel->input = MTP_inputPeerChannel(data.vid, data.vaccess_hash);
|
|
|
|
|
|
|
|
auto wasInChannel = channel->amIn();
|
|
|
|
auto canViewAdmins = channel->canViewAdmins();
|
|
|
|
auto canViewMembers = channel->canViewMembers();
|
|
|
|
auto canAddMembers = channel->canAddMembers();
|
|
|
|
|
|
|
|
channel->inputChannel = MTP_inputChannel(data.vid, data.vaccess_hash);
|
|
|
|
|
|
|
|
auto mask = mtpCastFlags(MTPDchannelForbidden::Flag::f_broadcast | MTPDchannelForbidden::Flag::f_megagroup);
|
|
|
|
channel->setFlags((channel->flags() & ~mask) | (mtpCastFlags(data.vflags) & mask) | MTPDchannel_ClientFlag::f_forbidden);
|
|
|
|
|
|
|
|
if (channel->hasAdminRights()) {
|
2019-01-03 14:39:19 +00:00
|
|
|
channel->setAdminRights(MTP_chatAdminRights(MTP_flags(0)));
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
if (channel->hasRestrictions()) {
|
2019-01-05 10:50:04 +00:00
|
|
|
channel->setRestrictions(MTP_chatBannedRights(MTP_flags(0), MTP_int(0)));
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
channel->setName(qs(data.vtitle), QString());
|
|
|
|
|
|
|
|
channel->access = data.vaccess_hash.v;
|
|
|
|
channel->setPhoto(MTP_chatPhotoEmpty());
|
|
|
|
channel->date = 0;
|
|
|
|
channel->setMembersCount(0);
|
|
|
|
|
|
|
|
if (wasInChannel != channel->amIn()) {
|
|
|
|
update.flags |= UpdateFlag::ChannelAmIn;
|
|
|
|
}
|
|
|
|
if (canViewAdmins != channel->canViewAdmins()
|
|
|
|
|| canViewMembers != channel->canViewMembers()
|
|
|
|
|| canAddMembers != channel->canAddMembers()) {
|
2019-01-05 10:50:04 +00:00
|
|
|
update.flags |= UpdateFlag::RightsChanged;
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
}, [](const MTPDchatEmpty &) {
|
|
|
|
});
|
|
|
|
|
|
|
|
if (minimal) {
|
|
|
|
if (result->loadedStatus == PeerData::NotLoaded) {
|
|
|
|
result->loadedStatus = PeerData::MinimalLoaded;
|
|
|
|
}
|
|
|
|
} else if (result->loadedStatus != PeerData::FullLoaded) {
|
|
|
|
result->loadedStatus = PeerData::FullLoaded;
|
|
|
|
}
|
|
|
|
if (update.flags) {
|
|
|
|
update.peer = result;
|
|
|
|
Notify::peerUpdatedDelayed(update);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
UserData *Session::processUsers(const MTPVector<MTPUser> &data) {
|
|
|
|
auto result = (UserData*)nullptr;
|
|
|
|
for (const auto &user : data.v) {
|
2019-01-18 12:27:37 +00:00
|
|
|
result = processUser(user);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
PeerData *Session::processChats(const MTPVector<MTPChat> &data) {
|
|
|
|
auto result = (PeerData*)nullptr;
|
|
|
|
for (const auto &chat : data.v) {
|
2019-01-18 12:27:37 +00:00
|
|
|
result = processChat(chat);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-01-13 08:03:34 +00:00
|
|
|
void Session::applyMaximumChatVersions(const MTPVector<MTPChat> &data) {
|
|
|
|
for (const auto &chat : data.v) {
|
|
|
|
chat.match([&](const MTPDchat &data) {
|
|
|
|
if (const auto chat = chatLoaded(data.vid.v)) {
|
|
|
|
if (data.vversion.v < chat->version()) {
|
|
|
|
chat->setVersion(data.vversion.v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, [&](const MTPDchannel &data) {
|
|
|
|
if (const auto channel = channelLoaded(data.vid.v)) {
|
|
|
|
if (data.vversion.v < channel->version()) {
|
|
|
|
channel->setVersion(data.vversion.v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}, [](const auto &) {
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
PeerData *Session::peerByUsername(const QString &username) const {
|
|
|
|
const auto uname = username.trimmed();
|
|
|
|
for (const auto &[peerId, peer] : _peers) {
|
|
|
|
if (!peer->userName().compare(uname, Qt::CaseInsensitive)) {
|
|
|
|
return peer.get();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::enumerateUsers(Fn<void(not_null<UserData*>)> action) const {
|
|
|
|
for (const auto &[peerId, peer] : _peers) {
|
|
|
|
if (const auto user = peer->asUser()) {
|
|
|
|
action(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::enumerateGroups(Fn<void(not_null<PeerData*>)> action) const {
|
|
|
|
for (const auto &[peerId, peer] : _peers) {
|
|
|
|
if (peer->isChat() || peer->isMegagroup()) {
|
|
|
|
action(peer.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::enumerateChannels(
|
|
|
|
Fn<void(not_null<ChannelData*>)> action) const {
|
|
|
|
for (const auto &[peerId, peer] : _peers) {
|
|
|
|
if (const auto channel = peer->asChannel()) {
|
|
|
|
if (!channel->isMegagroup()) {
|
|
|
|
action(channel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<History*> Session::history(PeerId peerId) {
|
|
|
|
Expects(peerId != 0);
|
|
|
|
|
|
|
|
if (const auto result = historyLoaded(peerId)) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
const auto [i, ok] = _histories.emplace(
|
|
|
|
peerId,
|
|
|
|
std::make_unique<History>(this, peerId));
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
History *Session::historyLoaded(PeerId peerId) const {
|
|
|
|
const auto i = peerId ? _histories.find(peerId) : end(_histories);
|
|
|
|
return (i != end(_histories)) ? i->second.get() : nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<History*> Session::history(not_null<const PeerData*> peer) {
|
|
|
|
return history(peer->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
History *Session::historyLoaded(const PeerData *peer) {
|
|
|
|
return peer ? historyLoaded(peer->id) : nullptr;
|
|
|
|
}
|
|
|
|
|
2019-03-25 11:49:57 +00:00
|
|
|
void Session::deleteConversationLocally(not_null<PeerData*> peer) {
|
|
|
|
const auto history = historyLoaded(peer);
|
|
|
|
if (history) {
|
2019-04-19 08:47:49 +00:00
|
|
|
if (history->folderKnown()) {
|
|
|
|
setChatPinned(history, false);
|
|
|
|
}
|
2019-03-25 11:49:57 +00:00
|
|
|
App::main()->removeDialog(history);
|
2019-04-08 09:16:45 +00:00
|
|
|
history->clear(peer->isChannel()
|
|
|
|
? History::ClearType::Unload
|
|
|
|
: History::ClearType::DeleteChat);
|
2019-03-25 11:49:57 +00:00
|
|
|
}
|
|
|
|
if (const auto channel = peer->asMegagroup()) {
|
|
|
|
channel->addFlags(MTPDchannel::Flag::f_left);
|
|
|
|
if (const auto from = channel->getMigrateFromChat()) {
|
|
|
|
if (const auto migrated = historyLoaded(from)) {
|
|
|
|
migrated->updateChatListExistence();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
void Session::registerSendAction(
|
|
|
|
not_null<History*> history,
|
|
|
|
not_null<UserData*> user,
|
|
|
|
const MTPSendMessageAction &action,
|
|
|
|
TimeId when) {
|
|
|
|
if (history->updateSendActionNeedsAnimating(user, action)) {
|
|
|
|
user->madeAction(when);
|
|
|
|
|
|
|
|
const auto i = _sendActions.find(history);
|
|
|
|
if (!_sendActions.contains(history)) {
|
2019-02-19 06:57:53 +00:00
|
|
|
_sendActions.emplace(history, crl::now());
|
2019-04-01 14:53:18 +00:00
|
|
|
_sendActionsAnimation.start();
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-01 14:53:18 +00:00
|
|
|
bool Session::sendActionsAnimationCallback(crl::time now) {
|
2019-01-03 12:36:01 +00:00
|
|
|
for (auto i = begin(_sendActions); i != end(_sendActions);) {
|
2019-04-01 14:53:18 +00:00
|
|
|
if (i->first->updateSendActionNeedsAnimating(now)) {
|
2019-01-03 12:36:01 +00:00
|
|
|
++i;
|
|
|
|
} else {
|
|
|
|
i = _sendActions.erase(i);
|
|
|
|
}
|
|
|
|
}
|
2019-04-01 14:53:18 +00:00
|
|
|
return !_sendActions.empty();
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-18 08:28:43 +00:00
|
|
|
bool Session::chatsListLoaded(Data::Folder *folder) {
|
2019-04-22 14:22:39 +00:00
|
|
|
return chatsList(folder)->loaded();
|
2019-04-18 08:28:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::chatsListChanged(FolderId folderId) {
|
|
|
|
chatsListChanged(folderId ? folder(folderId).get() : nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::chatsListChanged(Data::Folder *folder) {
|
|
|
|
_chatsListChanged.fire_copy(folder);
|
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
void Session::chatsListDone(Data::Folder *folder) {
|
2019-04-18 08:28:43 +00:00
|
|
|
if (folder) {
|
2019-04-22 14:22:39 +00:00
|
|
|
folder->setChatsListLoaded();
|
2019-04-18 08:28:43 +00:00
|
|
|
} else {
|
2019-04-22 14:22:39 +00:00
|
|
|
_chatsList.setLoaded();
|
2019-04-18 08:28:43 +00:00
|
|
|
}
|
|
|
|
_chatsListLoadedEvents.fire_copy(folder);
|
|
|
|
}
|
|
|
|
|
2018-08-27 11:35:58 +00:00
|
|
|
Storage::Cache::Database &Session::cache() {
|
2018-08-29 13:23:16 +00:00
|
|
|
return *_cache;
|
2018-08-27 11:35:58 +00:00
|
|
|
}
|
|
|
|
|
2019-02-25 17:26:08 +00:00
|
|
|
Storage::Cache::Database &Session::cacheBigFile() {
|
|
|
|
return *_bigFileCache;
|
|
|
|
}
|
|
|
|
|
2018-07-23 13:11:56 +00:00
|
|
|
void Session::startExport(PeerData *peer) {
|
|
|
|
startExport(peer ? peer->input : MTP_inputPeerEmpty());
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::startExport(const MTPInputPeer &singlePeer) {
|
2018-06-24 00:33:47 +00:00
|
|
|
if (_exportPanel) {
|
|
|
|
_exportPanel->activatePanel();
|
|
|
|
return;
|
|
|
|
}
|
2019-02-17 11:06:37 +00:00
|
|
|
_export = std::make_unique<Export::Controller>(singlePeer);
|
2018-06-20 00:02:36 +00:00
|
|
|
_exportPanel = std::make_unique<Export::View::PanelController>(
|
|
|
|
_export.get());
|
|
|
|
|
|
|
|
_exportViewChanges.fire(_exportPanel.get());
|
|
|
|
|
2018-06-21 00:54:59 +00:00
|
|
|
_exportPanel->stopRequests(
|
2018-06-20 00:02:36 +00:00
|
|
|
) | rpl::start_with_next([=] {
|
2018-06-24 02:15:12 +00:00
|
|
|
LOG(("Export Info: Stop requested."));
|
2018-06-20 17:30:57 +00:00
|
|
|
stopExport();
|
2018-06-20 00:02:36 +00:00
|
|
|
}, _export->lifetime());
|
|
|
|
}
|
|
|
|
|
2018-06-22 23:18:43 +00:00
|
|
|
void Session::suggestStartExport(TimeId availableAt) {
|
|
|
|
_exportAvailableAt = availableAt;
|
|
|
|
suggestStartExport();
|
|
|
|
}
|
|
|
|
|
2018-06-28 17:44:07 +00:00
|
|
|
void Session::clearExportSuggestion() {
|
|
|
|
_exportAvailableAt = 0;
|
|
|
|
if (_exportSuggestion) {
|
|
|
|
_exportSuggestion->closeBox();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-22 23:18:43 +00:00
|
|
|
void Session::suggestStartExport() {
|
|
|
|
if (_exportAvailableAt <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
2018-06-23 21:21:32 +00:00
|
|
|
|
2018-06-22 23:18:43 +00:00
|
|
|
const auto now = unixtime();
|
|
|
|
const auto left = (_exportAvailableAt <= now)
|
|
|
|
? 0
|
|
|
|
: (_exportAvailableAt - now);
|
2018-06-23 21:21:32 +00:00
|
|
|
if (left) {
|
2018-06-22 23:18:43 +00:00
|
|
|
App::CallDelayed(
|
2019-02-19 06:57:53 +00:00
|
|
|
std::min(left + 5, 3600) * crl::time(1000),
|
2018-06-22 23:18:43 +00:00
|
|
|
_session,
|
|
|
|
[=] { suggestStartExport(); });
|
2018-06-23 21:21:32 +00:00
|
|
|
} else if (_export) {
|
|
|
|
Export::View::ClearSuggestStart();
|
|
|
|
} else {
|
2018-06-28 17:44:07 +00:00
|
|
|
_exportSuggestion = Export::View::SuggestStart();
|
2018-06-22 23:18:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-20 00:02:36 +00:00
|
|
|
rpl::producer<Export::View::PanelController*> Session::currentExportView(
|
|
|
|
) const {
|
|
|
|
return _exportViewChanges.events_starting_with(_exportPanel.get());
|
|
|
|
}
|
|
|
|
|
2018-06-20 17:30:57 +00:00
|
|
|
bool Session::exportInProgress() const {
|
|
|
|
return _export != nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::stopExportWithConfirmation(FnMut<void()> callback) {
|
|
|
|
if (!_exportPanel) {
|
|
|
|
callback();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
auto closeAndCall = [=, callback = std::move(callback)]() mutable {
|
|
|
|
auto saved = std::move(callback);
|
2018-06-24 02:15:12 +00:00
|
|
|
LOG(("Export Info: Stop With Confirmation."));
|
2018-06-20 17:30:57 +00:00
|
|
|
stopExport();
|
|
|
|
if (saved) {
|
|
|
|
saved();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
_exportPanel->stopWithConfirmation(std::move(closeAndCall));
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::stopExport() {
|
2018-06-20 00:02:36 +00:00
|
|
|
if (_exportPanel) {
|
2018-06-24 02:15:12 +00:00
|
|
|
LOG(("Export Info: Destroying."));
|
2018-06-20 00:02:36 +00:00
|
|
|
_exportPanel = nullptr;
|
|
|
|
_exportViewChanges.fire(nullptr);
|
|
|
|
}
|
|
|
|
_export = nullptr;
|
|
|
|
}
|
|
|
|
|
2018-07-10 16:41:11 +00:00
|
|
|
const Passport::SavedCredentials *Session::passportCredentials() const {
|
|
|
|
return _passportCredentials ? &_passportCredentials->first : nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::rememberPassportCredentials(
|
|
|
|
Passport::SavedCredentials data,
|
2019-02-19 06:57:53 +00:00
|
|
|
crl::time rememberFor) {
|
2018-07-10 16:41:11 +00:00
|
|
|
Expects(rememberFor > 0);
|
|
|
|
|
|
|
|
static auto generation = 0;
|
|
|
|
_passportCredentials = std::make_unique<CredentialsWithGeneration>(
|
|
|
|
std::move(data),
|
|
|
|
++generation);
|
|
|
|
App::CallDelayed(rememberFor, _session, [=, check = generation] {
|
|
|
|
if (_passportCredentials && _passportCredentials->second == check) {
|
|
|
|
forgetPassportCredentials();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::forgetPassportCredentials() {
|
|
|
|
_passportCredentials = nullptr;
|
|
|
|
}
|
|
|
|
|
2018-02-08 09:20:14 +00:00
|
|
|
void Session::setupContactViewsViewer() {
|
2018-01-04 10:22:53 +00:00
|
|
|
Notify::PeerUpdateViewer(
|
|
|
|
Notify::PeerUpdate::Flag::UserIsContact
|
|
|
|
) | rpl::map([](const Notify::PeerUpdate &update) {
|
|
|
|
return update.peer->asUser();
|
|
|
|
}) | rpl::filter([](UserData *user) {
|
|
|
|
return user != nullptr;
|
|
|
|
}) | rpl::start_with_next([=](not_null<UserData*> user) {
|
|
|
|
userIsContactUpdated(user);
|
|
|
|
}, _lifetime);
|
|
|
|
}
|
|
|
|
|
2018-02-08 09:20:14 +00:00
|
|
|
void Session::setupChannelLeavingViewer() {
|
|
|
|
Notify::PeerUpdateViewer(
|
|
|
|
Notify::PeerUpdate::Flag::ChannelAmIn
|
|
|
|
) | rpl::map([](const Notify::PeerUpdate &update) {
|
|
|
|
return update.peer->asChannel();
|
|
|
|
}) | rpl::filter([](ChannelData *channel) {
|
|
|
|
return (channel != nullptr)
|
2018-05-11 14:03:53 +00:00
|
|
|
&& !(channel->amIn());
|
2018-02-08 09:20:14 +00:00
|
|
|
}) | rpl::start_with_next([=](not_null<ChannelData*> channel) {
|
2019-04-15 11:54:03 +00:00
|
|
|
// channel->clearFeed(); // #feed
|
2019-01-03 12:36:01 +00:00
|
|
|
if (const auto history = historyLoaded(channel->id)) {
|
2018-05-11 14:03:53 +00:00
|
|
|
history->removeJoinedMessage();
|
|
|
|
history->updateChatListExistence();
|
|
|
|
history->updateChatListSortPosition();
|
|
|
|
}
|
2018-02-08 09:20:14 +00:00
|
|
|
}, _lifetime);
|
|
|
|
}
|
|
|
|
|
2019-04-16 14:05:56 +00:00
|
|
|
void Session::setupPeerNameViewer() {
|
|
|
|
Notify::PeerUpdateViewer(
|
|
|
|
Notify::PeerUpdate::Flag::NameChanged
|
|
|
|
) | rpl::start_with_next([=](const Notify::PeerUpdate &update) {
|
|
|
|
const auto peer = update.peer;
|
|
|
|
const auto &oldLetters = update.oldNameFirstLetters;
|
|
|
|
_contactsNoChatsList.peerNameChanged(peer, oldLetters);
|
|
|
|
_contactsList.peerNameChanged(peer, oldLetters);
|
|
|
|
}, _lifetime);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::setupUserIsContactViewer() {
|
|
|
|
Notify::PeerUpdateViewer(
|
|
|
|
Notify::PeerUpdate::Flag::UserIsContact
|
|
|
|
) | rpl::filter([=](const Notify::PeerUpdate &update) {
|
|
|
|
return update.peer->isUser();
|
|
|
|
}) | rpl::start_with_next([=](const Notify::PeerUpdate &update) {
|
|
|
|
const auto user = update.peer->asUser();
|
|
|
|
if (user->loadedStatus != PeerData::FullLoaded) {
|
|
|
|
LOG(("API Error: "
|
|
|
|
"userIsContactChanged() called for a not loaded user!"));
|
|
|
|
return;
|
|
|
|
}
|
2019-06-06 16:48:42 +00:00
|
|
|
if (user->isContact()) {
|
2019-04-16 14:05:56 +00:00
|
|
|
const auto history = user->owner().history(user->id);
|
|
|
|
_contactsList.addByName(history);
|
2019-04-22 18:18:57 +00:00
|
|
|
if (!history->inChatList()) {
|
2019-04-16 14:05:56 +00:00
|
|
|
_contactsNoChatsList.addByName(history);
|
|
|
|
}
|
|
|
|
} else if (const auto history = user->owner().historyLoaded(user)) {
|
|
|
|
_contactsNoChatsList.del(history);
|
|
|
|
_contactsList.del(history);
|
|
|
|
}
|
|
|
|
}, _lifetime);
|
|
|
|
}
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
Session::~Session() {
|
|
|
|
// Optimization: clear notifications before destroying items.
|
|
|
|
_session->notifications().clearAllFast();
|
|
|
|
|
|
|
|
clear();
|
|
|
|
Images::ClearRemote();
|
|
|
|
}
|
2018-01-04 10:22:53 +00:00
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
template <typename Method>
|
|
|
|
void Session::enumerateItemViews(
|
2018-01-18 11:46:45 +00:00
|
|
|
not_null<const HistoryItem*> item,
|
2018-01-17 16:21:01 +00:00
|
|
|
Method method) {
|
|
|
|
if (const auto i = _views.find(item); i != _views.end()) {
|
|
|
|
for (const auto view : i->second) {
|
|
|
|
method(view);
|
|
|
|
}
|
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Session::photoLoadSettingsChanged() {
|
|
|
|
for (const auto &[id, photo] : _photos) {
|
|
|
|
photo->automaticLoadSettingsChanged();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-06 15:47:28 +00:00
|
|
|
void Session::documentLoadSettingsChanged() {
|
2018-01-17 16:21:01 +00:00
|
|
|
for (const auto &[id, document] : _documents) {
|
2018-12-06 15:47:28 +00:00
|
|
|
document->automaticLoadSettingsChanged();
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::notifyPhotoLayoutChanged(not_null<const PhotoData*> photo) {
|
2018-01-21 19:52:44 +00:00
|
|
|
if (const auto i = _photoItems.find(photo); i != end(_photoItems)) {
|
|
|
|
for (const auto item : i->second) {
|
|
|
|
notifyItemLayoutChange(item);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::notifyDocumentLayoutChanged(
|
|
|
|
not_null<const DocumentData*> document) {
|
2018-01-21 19:52:44 +00:00
|
|
|
const auto i = _documentItems.find(document);
|
|
|
|
if (i != end(_documentItems)) {
|
|
|
|
for (const auto item : i->second) {
|
|
|
|
notifyItemLayoutChange(item);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
if (const auto items = InlineBots::Layout::documentItems()) {
|
|
|
|
if (const auto i = items->find(document); i != items->end()) {
|
|
|
|
for (const auto item : i->second) {
|
|
|
|
item->layoutChanged();
|
|
|
|
}
|
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::requestDocumentViewRepaint(
|
|
|
|
not_null<const DocumentData*> document) {
|
2018-01-21 19:52:44 +00:00
|
|
|
const auto i = _documentItems.find(document);
|
|
|
|
if (i != end(_documentItems)) {
|
|
|
|
for (const auto item : i->second) {
|
|
|
|
requestItemRepaint(item);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-10 11:26:15 +00:00
|
|
|
std::shared_ptr<::Media::Streaming::Reader> Session::documentStreamedReader(
|
|
|
|
not_null<DocumentData*> document,
|
2019-04-12 09:25:00 +00:00
|
|
|
FileOrigin origin,
|
|
|
|
bool forceRemoteLoader) {
|
2019-04-10 11:26:15 +00:00
|
|
|
const auto i = _streamedReaders.find(document);
|
|
|
|
if (i != end(_streamedReaders)) {
|
|
|
|
if (auto result = i->second.lock()) {
|
2019-04-12 09:25:00 +00:00
|
|
|
if (!forceRemoteLoader || result->isRemoteLoader()) {
|
|
|
|
return result;
|
|
|
|
}
|
2019-04-10 11:26:15 +00:00
|
|
|
}
|
|
|
|
}
|
2019-04-12 09:25:00 +00:00
|
|
|
auto loader = document->createStreamingLoader(origin, forceRemoteLoader);
|
2019-04-10 11:26:15 +00:00
|
|
|
if (!loader) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
auto result = std::make_shared<::Media::Streaming::Reader>(
|
2019-06-26 10:01:04 +00:00
|
|
|
&cacheBigFile(),
|
2019-04-10 11:26:15 +00:00
|
|
|
std::move(loader));
|
|
|
|
if (!PruneDestroyedAndSet(_streamedReaders, document, result)) {
|
2019-04-12 09:25:00 +00:00
|
|
|
_streamedReaders.emplace_or_assign(document, result);
|
2019-04-10 11:26:15 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-12-18 05:43:11 +00:00
|
|
|
void Session::requestPollViewRepaint(not_null<const PollData*> poll) {
|
|
|
|
if (const auto i = _pollViews.find(poll); i != _pollViews.end()) {
|
|
|
|
for (const auto view : i->second) {
|
|
|
|
requestViewResize(view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Session::markMediaRead(not_null<const DocumentData*> document) {
|
|
|
|
const auto i = _documentItems.find(document);
|
|
|
|
if (i != end(_documentItems)) {
|
|
|
|
_session->api().markMediaRead({ begin(i->second), end(i->second) });
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-21 19:52:44 +00:00
|
|
|
void Session::notifyItemLayoutChange(not_null<const HistoryItem*> item) {
|
|
|
|
_itemLayoutChanges.fire_copy(item);
|
|
|
|
enumerateItemViews(item, [&](not_null<ViewElement*> view) {
|
|
|
|
notifyViewLayoutChange(view);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<const HistoryItem*>> Session::itemLayoutChanged() const {
|
|
|
|
return _itemLayoutChanges.events();
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
void Session::notifyViewLayoutChange(not_null<const ViewElement*> view) {
|
2018-01-14 16:02:25 +00:00
|
|
|
_viewLayoutChanges.fire_copy(view);
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
rpl::producer<not_null<const ViewElement*>> Session::viewLayoutChanged() const {
|
2018-01-14 16:02:25 +00:00
|
|
|
return _viewLayoutChanges.events();
|
|
|
|
}
|
|
|
|
|
2019-04-25 12:45:15 +00:00
|
|
|
void Session::changeMessageId(ChannelId channel, MsgId wasId, MsgId nowId) {
|
|
|
|
const auto list = messagesListForInsert(channel);
|
|
|
|
auto i = list->find(wasId);
|
|
|
|
Assert(i != list->end());
|
|
|
|
auto owned = std::move(i->second);
|
|
|
|
list->erase(i);
|
|
|
|
list->emplace(nowId, std::move(owned));
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
void Session::notifyItemIdChange(IdChange event) {
|
2019-04-25 12:45:15 +00:00
|
|
|
const auto item = event.item;
|
|
|
|
changeMessageId(item->history()->channelId(), event.oldId, item->id);
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
_itemIdChanges.fire_copy(event);
|
2018-01-19 17:10:58 +00:00
|
|
|
|
|
|
|
const auto refreshViewDataId = [](not_null<ViewElement*> view) {
|
|
|
|
view->refreshDataId();
|
|
|
|
};
|
2019-04-25 12:45:15 +00:00
|
|
|
enumerateItemViews(item, refreshViewDataId);
|
|
|
|
if (const auto group = groups().find(item)) {
|
2018-01-19 17:10:58 +00:00
|
|
|
const auto leader = group->items.back();
|
2019-04-25 12:45:15 +00:00
|
|
|
if (leader != item) {
|
2018-01-19 17:10:58 +00:00
|
|
|
enumerateItemViews(leader, refreshViewDataId);
|
|
|
|
}
|
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<Session::IdChange> Session::itemIdChanged() const {
|
|
|
|
return _itemIdChanges.events();
|
2018-01-04 10:22:53 +00:00
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
void Session::requestItemRepaint(not_null<const HistoryItem*> item) {
|
|
|
|
_itemRepaintRequest.fire_copy(item);
|
|
|
|
enumerateItemViews(item, [&](not_null<const ViewElement*> view) {
|
|
|
|
requestViewRepaint(view);
|
|
|
|
});
|
2018-01-04 10:22:53 +00:00
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
rpl::producer<not_null<const HistoryItem*>> Session::itemRepaintRequest() const {
|
|
|
|
return _itemRepaintRequest.events();
|
2018-01-04 10:22:53 +00:00
|
|
|
}
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
void Session::requestViewRepaint(not_null<const ViewElement*> view) {
|
|
|
|
_viewRepaintRequest.fire_copy(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<const ViewElement*>> Session::viewRepaintRequest() const {
|
|
|
|
return _viewRepaintRequest.events();
|
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
void Session::requestItemResize(not_null<const HistoryItem*> item) {
|
|
|
|
_itemResizeRequest.fire_copy(item);
|
|
|
|
enumerateItemViews(item, [&](not_null<ViewElement*> view) {
|
|
|
|
requestViewResize(view);
|
|
|
|
});
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
rpl::producer<not_null<const HistoryItem*>> Session::itemResizeRequest() const {
|
|
|
|
return _itemResizeRequest.events();
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
void Session::requestViewResize(not_null<ViewElement*> view) {
|
2018-01-19 17:10:58 +00:00
|
|
|
view->setPendingResize();
|
2018-01-14 16:02:25 +00:00
|
|
|
_viewResizeRequest.fire_copy(view);
|
2018-01-21 14:49:42 +00:00
|
|
|
notifyViewLayoutChange(view);
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
rpl::producer<not_null<ViewElement*>> Session::viewResizeRequest() const {
|
2018-01-14 16:02:25 +00:00
|
|
|
return _viewResizeRequest.events();
|
|
|
|
}
|
|
|
|
|
2018-01-18 13:59:22 +00:00
|
|
|
void Session::requestItemViewRefresh(not_null<HistoryItem*> item) {
|
2018-01-18 11:46:45 +00:00
|
|
|
if (const auto view = item->mainView()) {
|
|
|
|
view->setPendingResize();
|
|
|
|
}
|
2018-01-13 12:45:11 +00:00
|
|
|
_itemViewRefreshRequest.fire_copy(item);
|
|
|
|
}
|
|
|
|
|
2018-01-18 13:59:22 +00:00
|
|
|
rpl::producer<not_null<HistoryItem*>> Session::itemViewRefreshRequest() const {
|
2018-01-13 12:45:11 +00:00
|
|
|
return _itemViewRefreshRequest.events();
|
|
|
|
}
|
|
|
|
|
2018-03-13 10:19:06 +00:00
|
|
|
void Session::requestItemTextRefresh(not_null<HistoryItem*> item) {
|
|
|
|
if (const auto i = _views.find(item); i != _views.end()) {
|
|
|
|
for (const auto view : i->second) {
|
|
|
|
if (const auto media = view->media()) {
|
|
|
|
media->parentTextUpdated();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-21 14:49:42 +00:00
|
|
|
void Session::requestAnimationPlayInline(not_null<HistoryItem*> item) {
|
|
|
|
_animationPlayInlineRequest.fire_copy(item);
|
2019-03-26 08:54:51 +00:00
|
|
|
|
|
|
|
if (const auto media = item->media()) {
|
|
|
|
if (const auto data = media->document()) {
|
|
|
|
if (data && data->isVideoMessage()) {
|
|
|
|
const auto msgId = item->fullId();
|
|
|
|
::Media::Player::instance()->playPause({ data, msgId });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
2018-01-21 14:49:42 +00:00
|
|
|
rpl::producer<not_null<HistoryItem*>> Session::animationPlayInlineRequest() const {
|
|
|
|
return _animationPlayInlineRequest.events();
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 10:22:53 +00:00
|
|
|
rpl::producer<not_null<const HistoryItem*>> Session::itemRemoved() const {
|
|
|
|
return _itemRemoved.events();
|
|
|
|
}
|
|
|
|
|
2018-03-09 11:44:42 +00:00
|
|
|
void Session::notifyViewRemoved(not_null<const ViewElement*> view) {
|
|
|
|
_viewRemoved.fire_copy(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<const ViewElement*>> Session::viewRemoved() const {
|
|
|
|
return _viewRemoved.events();
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
void Session::notifyHistoryUnloaded(not_null<const History*> history) {
|
2018-01-04 10:22:53 +00:00
|
|
|
_historyUnloaded.fire_copy(history);
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<const History*>> Session::historyUnloaded() const {
|
|
|
|
return _historyUnloaded.events();
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
void Session::notifyHistoryCleared(not_null<const History*> history) {
|
2018-01-04 10:22:53 +00:00
|
|
|
_historyCleared.fire_copy(history);
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<const History*>> Session::historyCleared() const {
|
|
|
|
return _historyCleared.events();
|
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
void Session::notifyHistoryChangeDelayed(not_null<History*> history) {
|
2018-01-19 17:10:58 +00:00
|
|
|
history->setHasPendingResizedItems();
|
2018-01-18 09:53:49 +00:00
|
|
|
_historiesChanged.insert(history);
|
|
|
|
}
|
|
|
|
|
2018-01-18 11:46:45 +00:00
|
|
|
rpl::producer<not_null<History*>> Session::historyChanged() const {
|
2018-01-18 09:53:49 +00:00
|
|
|
return _historyChanged.events();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::sendHistoryChangeNotifications() {
|
|
|
|
for (const auto history : base::take(_historiesChanged)) {
|
|
|
|
_historyChanged.fire_copy(history);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-14 09:50:44 +00:00
|
|
|
void Session::registerHeavyViewPart(not_null<ViewElement*> view) {
|
|
|
|
_heavyViewParts.emplace(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterHeavyViewPart(not_null<ViewElement*> view) {
|
|
|
|
_heavyViewParts.remove(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unloadHeavyViewParts(
|
|
|
|
not_null<HistoryView::ElementDelegate*> delegate) {
|
|
|
|
if (_heavyViewParts.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const auto remove = ranges::count(_heavyViewParts, delegate, [](not_null<ViewElement*> element) {
|
|
|
|
return element->delegate();
|
|
|
|
});
|
|
|
|
if (remove == _heavyViewParts.size()) {
|
|
|
|
for (const auto view : base::take(_heavyViewParts)) {
|
|
|
|
view->unloadHeavyPart();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
auto remove = std::vector<not_null<ViewElement*>>();
|
|
|
|
for (const auto view : _heavyViewParts) {
|
|
|
|
if (view->delegate() == delegate) {
|
|
|
|
remove.push_back(view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const auto view : remove) {
|
|
|
|
view->unloadHeavyPart();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unloadHeavyViewParts(
|
|
|
|
not_null<HistoryView::ElementDelegate*> delegate,
|
|
|
|
int from,
|
|
|
|
int till) {
|
|
|
|
if (_heavyViewParts.empty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
auto remove = std::vector<not_null<ViewElement*>>();
|
|
|
|
for (const auto view : _heavyViewParts) {
|
|
|
|
if (view->delegate() == delegate
|
|
|
|
&& !delegate->elementIntersectsRange(view, from, till)) {
|
|
|
|
remove.push_back(view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const auto view : remove) {
|
|
|
|
view->unloadHeavyPart();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-04 10:22:53 +00:00
|
|
|
void Session::removeMegagroupParticipant(
|
|
|
|
not_null<ChannelData*> channel,
|
|
|
|
not_null<UserData*> user) {
|
|
|
|
_megagroupParticipantRemoved.fire({ channel, user });
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Session::megagroupParticipantRemoved() const
|
|
|
|
-> rpl::producer<MegagroupParticipant> {
|
|
|
|
return _megagroupParticipantRemoved.events();
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<UserData*>> Session::megagroupParticipantRemoved(
|
|
|
|
not_null<ChannelData*> channel) const {
|
|
|
|
return megagroupParticipantRemoved(
|
|
|
|
) | rpl::filter([channel](auto updateChannel, auto user) {
|
|
|
|
return (updateChannel == channel);
|
|
|
|
}) | rpl::map([](auto updateChannel, auto user) {
|
|
|
|
return user;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::addNewMegagroupParticipant(
|
|
|
|
not_null<ChannelData*> channel,
|
|
|
|
not_null<UserData*> user) {
|
|
|
|
_megagroupParticipantAdded.fire({ channel, user });
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Session::megagroupParticipantAdded() const
|
|
|
|
-> rpl::producer<MegagroupParticipant> {
|
|
|
|
return _megagroupParticipantAdded.events();
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<not_null<UserData*>> Session::megagroupParticipantAdded(
|
|
|
|
not_null<ChannelData*> channel) const {
|
|
|
|
return megagroupParticipantAdded(
|
|
|
|
) | rpl::filter([channel](auto updateChannel, auto user) {
|
|
|
|
return (updateChannel == channel);
|
|
|
|
}) | rpl::map([](auto updateChannel, auto user) {
|
|
|
|
return user;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
void Session::notifyStickersUpdated() {
|
2018-01-04 10:22:53 +00:00
|
|
|
_stickersUpdated.fire({});
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::stickersUpdated() const {
|
|
|
|
return _stickersUpdated.events();
|
|
|
|
}
|
|
|
|
|
2019-06-12 19:49:28 +00:00
|
|
|
void Session::notifyRecentStickersUpdated() {
|
|
|
|
_recentStickersUpdated.fire({});
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::recentStickersUpdated() const {
|
|
|
|
return _recentStickersUpdated.events();
|
|
|
|
}
|
|
|
|
|
2018-01-17 18:20:55 +00:00
|
|
|
void Session::notifySavedGifsUpdated() {
|
2018-01-04 10:22:53 +00:00
|
|
|
_savedGifsUpdated.fire({});
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::savedGifsUpdated() const {
|
|
|
|
return _savedGifsUpdated.events();
|
|
|
|
}
|
|
|
|
|
2019-05-01 13:18:31 +00:00
|
|
|
void Session::notifyPinnedDialogsOrderUpdated() {
|
|
|
|
_pinnedDialogsOrderUpdated.fire({});
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::pinnedDialogsOrderUpdated() const {
|
|
|
|
return _pinnedDialogsOrderUpdated.events();
|
|
|
|
}
|
|
|
|
|
2018-01-04 10:22:53 +00:00
|
|
|
void Session::userIsContactUpdated(not_null<UserData*> user) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto i = _contactViews.find(peerToUser(user->id));
|
|
|
|
if (i != _contactViews.end()) {
|
|
|
|
for (const auto view : i->second) {
|
|
|
|
requestViewResize(view);
|
2018-01-04 10:22:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
HistoryItemsList Session::idsToItems(
|
|
|
|
const MessageIdsList &ids) const {
|
|
|
|
return ranges::view::all(
|
|
|
|
ids
|
2019-04-25 12:45:15 +00:00
|
|
|
) | ranges::view::transform([&](const FullMsgId &fullId) {
|
|
|
|
return message(fullId);
|
2018-01-04 10:22:53 +00:00
|
|
|
}) | ranges::view::filter([](HistoryItem *item) {
|
|
|
|
return item != nullptr;
|
|
|
|
}) | ranges::view::transform([](HistoryItem *item) {
|
|
|
|
return not_null<HistoryItem*>(item);
|
|
|
|
}) | ranges::to_vector;
|
|
|
|
}
|
|
|
|
|
|
|
|
MessageIdsList Session::itemsToIds(
|
|
|
|
const HistoryItemsList &items) const {
|
|
|
|
return ranges::view::all(
|
|
|
|
items
|
|
|
|
) | ranges::view::transform([](not_null<HistoryItem*> item) {
|
|
|
|
return item->fullId();
|
|
|
|
}) | ranges::to_vector;
|
|
|
|
}
|
|
|
|
|
2018-01-11 15:51:59 +00:00
|
|
|
MessageIdsList Session::itemOrItsGroup(not_null<HistoryItem*> item) const {
|
2018-01-14 16:02:25 +00:00
|
|
|
if (const auto group = groups().find(item)) {
|
|
|
|
return itemsToIds(group->items);
|
2018-01-11 15:51:59 +00:00
|
|
|
}
|
|
|
|
return { 1, item->fullId() };
|
|
|
|
}
|
|
|
|
|
2019-04-19 08:47:49 +00:00
|
|
|
void Session::setChatPinned(const Dialogs::Key &key, bool pinned) {
|
|
|
|
Expects(key.entry()->folderKnown());
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
const auto list = chatsList(key.entry()->folder())->pinned();
|
|
|
|
list->setPinned(key, pinned);
|
2019-05-02 13:26:47 +00:00
|
|
|
notifyPinnedDialogsOrderUpdated();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
|
|
|
|
2019-04-19 08:47:49 +00:00
|
|
|
void Session::setPinnedFromDialog(const Dialogs::Key &key, bool pinned) {
|
|
|
|
Expects(key.entry()->folderKnown());
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
const auto list = chatsList(key.entry()->folder())->pinned();
|
|
|
|
if (pinned) {
|
|
|
|
list->addPinned(key);
|
2019-04-19 08:47:49 +00:00
|
|
|
} else {
|
2019-04-22 14:22:39 +00:00
|
|
|
list->setPinned(key, false);
|
2019-04-19 08:47:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::applyPinnedChats(
|
2019-04-22 14:22:39 +00:00
|
|
|
Data::Folder *folder,
|
2019-04-19 08:47:49 +00:00
|
|
|
const QVector<MTPDialogPeer> &list) {
|
|
|
|
for (const auto &peer : list) {
|
|
|
|
peer.match([&](const MTPDdialogPeer &data) {
|
|
|
|
const auto history = this->history(peerFromMTP(data.vpeer));
|
|
|
|
if (folder) {
|
|
|
|
history->setFolder(folder);
|
|
|
|
} else {
|
|
|
|
history->clearFolder();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
2019-04-16 08:50:59 +00:00
|
|
|
}, [&](const MTPDdialogPeerFolder &data) {
|
2019-04-19 08:47:49 +00:00
|
|
|
if (folder) {
|
|
|
|
LOG(("API Error: Nested folders detected."));
|
|
|
|
}
|
2019-04-15 11:54:03 +00:00
|
|
|
});
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
2019-04-22 14:22:39 +00:00
|
|
|
chatsList(folder)->pinned()->applyList(this, list);
|
2019-05-02 13:26:47 +00:00
|
|
|
notifyPinnedDialogsOrderUpdated();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
|
|
|
|
2019-04-16 16:28:41 +00:00
|
|
|
void Session::applyDialogs(
|
2019-04-22 14:22:39 +00:00
|
|
|
Data::Folder *requestFolder,
|
2019-04-16 16:28:41 +00:00
|
|
|
const QVector<MTPMessage> &messages,
|
2019-04-23 12:29:23 +00:00
|
|
|
const QVector<MTPDialog> &dialogs,
|
|
|
|
std::optional<int> count) {
|
2019-04-25 12:45:15 +00:00
|
|
|
processMessages(messages, NewMessageType::Last);
|
2019-04-16 16:28:41 +00:00
|
|
|
for (const auto &dialog : dialogs) {
|
|
|
|
dialog.match([&](const auto &data) {
|
2019-04-22 14:22:39 +00:00
|
|
|
applyDialog(requestFolder, data);
|
2019-04-16 16:28:41 +00:00
|
|
|
});
|
|
|
|
}
|
2019-04-23 12:29:23 +00:00
|
|
|
if (requestFolder && count) {
|
|
|
|
requestFolder->setCloudChatsListSize(*count);
|
|
|
|
}
|
2019-04-16 16:28:41 +00:00
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
void Session::applyDialog(
|
|
|
|
Data::Folder *requestFolder,
|
|
|
|
const MTPDdialog &data) {
|
2019-04-16 16:28:41 +00:00
|
|
|
const auto peerId = peerFromMTP(data.vpeer);
|
|
|
|
if (!peerId) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto history = session().data().history(peerId);
|
2019-04-22 14:22:39 +00:00
|
|
|
history->applyDialog(requestFolder, data);
|
2019-04-19 08:47:49 +00:00
|
|
|
setPinnedFromDialog(history, data.is_pinned());
|
2019-04-16 16:28:41 +00:00
|
|
|
|
|
|
|
if (const auto from = history->peer->migrateFrom()) {
|
|
|
|
if (const auto historyFrom = from->owner().historyLoaded(from)) {
|
|
|
|
App::main()->removeDialog(historyFrom);
|
|
|
|
}
|
|
|
|
} else if (const auto to = history->peer->migrateTo()) {
|
|
|
|
if (to->amIn()) {
|
|
|
|
App::main()->removeDialog(history);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:08:02 +00:00
|
|
|
void Session::applyDialog(
|
2019-04-22 14:22:39 +00:00
|
|
|
Data::Folder *requestFolder,
|
2019-04-19 08:47:49 +00:00
|
|
|
const MTPDdialogFolder &data) {
|
2019-04-22 14:22:39 +00:00
|
|
|
if (requestFolder) {
|
|
|
|
LOG(("API Error: requestFolder != nullptr for dialogFolder."));
|
2019-04-17 12:08:02 +00:00
|
|
|
}
|
2019-04-19 08:47:49 +00:00
|
|
|
const auto folder = processFolder(data.vfolder);
|
|
|
|
folder->applyDialog(data);
|
|
|
|
setPinnedFromDialog(folder, data.is_pinned());
|
2019-04-16 16:28:41 +00:00
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
int Session::pinnedChatsCount(Data::Folder *folder) const {
|
|
|
|
return pinnedChatsOrder(folder).size();
|
2019-04-19 08:47:49 +00:00
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
int Session::pinnedChatsLimit(Data::Folder *folder) const {
|
|
|
|
return folder
|
2019-04-19 08:47:49 +00:00
|
|
|
? Global::PinnedDialogsInFolderMax()
|
|
|
|
: Global::PinnedDialogsCountMax();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
|
|
|
|
2019-04-19 08:47:49 +00:00
|
|
|
const std::vector<Dialogs::Key> &Session::pinnedChatsOrder(
|
2019-04-22 14:22:39 +00:00
|
|
|
Data::Folder *folder) const {
|
|
|
|
return chatsList(folder)->pinned()->order();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
void Session::clearPinnedChats(Data::Folder *folder) {
|
|
|
|
chatsList(folder)->pinned()->clear();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
|
|
|
|
2019-04-19 08:47:49 +00:00
|
|
|
void Session::reorderTwoPinnedChats(
|
2018-01-04 19:54:35 +00:00
|
|
|
const Dialogs::Key &key1,
|
|
|
|
const Dialogs::Key &key2) {
|
2019-04-19 08:47:49 +00:00
|
|
|
Expects(key1.entry()->folderKnown() && key2.entry()->folderKnown());
|
|
|
|
Expects(key1.entry()->folder() == key2.entry()->folder());
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
chatsList(key1.entry()->folder())->pinned()->reorder(key1, key2);
|
2019-05-02 13:26:47 +00:00
|
|
|
notifyPinnedDialogsOrderUpdated();
|
2018-01-04 19:54:35 +00:00
|
|
|
}
|
|
|
|
|
2019-04-25 12:45:15 +00:00
|
|
|
bool Session::checkEntitiesAndViewsUpdate(const MTPDmessage &data) {
|
|
|
|
const auto peer = [&] {
|
|
|
|
const auto result = peerFromMTP(data.vto_id);
|
|
|
|
return (data.has_from_id() && result == session().userPeerId())
|
|
|
|
? peerFromUser(data.vfrom_id)
|
|
|
|
: result;
|
|
|
|
}();
|
|
|
|
if (const auto existing = message(peerToChannel(peer), data.vid.v)) {
|
|
|
|
{
|
|
|
|
auto text = qs(data.vmessage);
|
|
|
|
auto entities = data.has_entities()
|
|
|
|
? TextUtilities::EntitiesFromMTP(data.ventities.v)
|
|
|
|
: EntitiesInText();
|
|
|
|
existing->setText({ std::move(text), std::move(entities) });
|
|
|
|
}
|
|
|
|
existing->updateSentMedia(data.has_media() ? &data.vmedia : nullptr);
|
|
|
|
existing->updateReplyMarkup(data.has_reply_markup()
|
|
|
|
? &data.vreply_markup
|
|
|
|
: nullptr);
|
|
|
|
existing->updateForwardedInfo(data.has_fwd_from()
|
|
|
|
? &data.vfwd_from
|
|
|
|
: nullptr);
|
|
|
|
existing->setViewsCount(data.has_views() ? data.vviews.v : -1);
|
|
|
|
existing->indexAsNewItem();
|
|
|
|
requestItemTextRefresh(existing);
|
|
|
|
if (existing->mainView()) {
|
|
|
|
App::checkSavedGif(existing);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::updateEditedMessage(const MTPMessage &data) {
|
|
|
|
const auto existing = data.match([](const MTPDmessageEmpty &)
|
|
|
|
-> HistoryItem* {
|
|
|
|
return nullptr;
|
|
|
|
}, [&](const auto &data) {
|
|
|
|
const auto peer = [&] {
|
|
|
|
const auto result = peerFromMTP(data.vto_id);
|
|
|
|
return (data.has_from_id() && result == session().userPeerId())
|
|
|
|
? peerFromUser(data.vfrom_id)
|
|
|
|
: result;
|
|
|
|
}();
|
|
|
|
return message(peerToChannel(peer), data.vid.v);
|
|
|
|
});
|
|
|
|
if (!existing) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (existing->isLocalUpdateMedia() && data.type() == mtpc_message) {
|
|
|
|
checkEntitiesAndViewsUpdate(data.c_message());
|
|
|
|
}
|
|
|
|
data.match([](const MTPDmessageEmpty &) {
|
|
|
|
}, [&](const auto &data) {
|
|
|
|
existing->applyEdition(data);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::processMessages(
|
|
|
|
const QVector<MTPMessage> &data,
|
|
|
|
NewMessageType type) {
|
|
|
|
auto indices = base::flat_map<uint64, int>();
|
|
|
|
for (int i = 0, l = data.size(); i != l; ++i) {
|
|
|
|
const auto &message = data[i];
|
|
|
|
if (message.type() == mtpc_message) {
|
|
|
|
const auto &data = message.c_message();
|
|
|
|
// new message, index my forwarded messages to links overview
|
|
|
|
if ((type == NewMessageType::Unread)
|
|
|
|
&& checkEntitiesAndViewsUpdate(data)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
const auto id = IdFromMessage(message);
|
|
|
|
indices.emplace((uint64(uint32(id)) << 32) | uint64(i), i);
|
|
|
|
}
|
|
|
|
for (const auto [position, index] : indices) {
|
|
|
|
addNewMessage(data[index], type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::processMessages(
|
|
|
|
const MTPVector<MTPMessage> &data,
|
|
|
|
NewMessageType type) {
|
|
|
|
processMessages(data.v, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
const Session::Messages *Session::messagesList(ChannelId channelId) const {
|
|
|
|
if (channelId == NoChannel) {
|
|
|
|
return &_messages;
|
|
|
|
}
|
|
|
|
const auto i = _channelMessages.find(channelId);
|
|
|
|
return (i != end(_channelMessages)) ? &i->second : nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Session::messagesListForInsert(ChannelId channelId)
|
|
|
|
-> not_null<Messages*> {
|
|
|
|
return (channelId == NoChannel)
|
|
|
|
? &_messages
|
|
|
|
: &_channelMessages[channelId];
|
|
|
|
}
|
|
|
|
|
|
|
|
HistoryItem *Session::registerMessage(std::unique_ptr<HistoryItem> item) {
|
|
|
|
Expects(item != nullptr);
|
|
|
|
|
|
|
|
const auto result = item.get();
|
|
|
|
const auto list = messagesListForInsert(result->channelId());
|
|
|
|
const auto i = list->find(result->id);
|
|
|
|
if (i != list->end()) {
|
|
|
|
LOG(("App Error: Trying to re-registerMessage()."));
|
|
|
|
i->second->destroy();
|
|
|
|
}
|
|
|
|
list->emplace(result->id, std::move(item));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::processMessagesDeleted(
|
|
|
|
ChannelId channelId,
|
|
|
|
const QVector<MTPint> &data) {
|
|
|
|
const auto list = messagesList(channelId);
|
|
|
|
const auto affected = (channelId != NoChannel)
|
|
|
|
? historyLoaded(peerFromChannel(channelId))
|
|
|
|
: nullptr;
|
|
|
|
if (!list && !affected) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto historiesToCheck = base::flat_set<not_null<History*>>();
|
|
|
|
for (const auto messageId : data) {
|
|
|
|
const auto i = list ? list->find(messageId.v) : Messages::iterator();
|
|
|
|
if (list && i != list->end()) {
|
|
|
|
const auto history = i->second->history();
|
|
|
|
destroyMessage(i->second.get());
|
|
|
|
if (!history->chatListMessageKnown()) {
|
|
|
|
historiesToCheck.emplace(history);
|
|
|
|
}
|
|
|
|
} else if (affected) {
|
|
|
|
affected->unknownMessageDeleted(messageId.v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const auto history : historiesToCheck) {
|
|
|
|
history->requestChatListMessage();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-30 08:04:42 +00:00
|
|
|
void Session::removeDependencyMessage(not_null<HistoryItem*> item) {
|
|
|
|
const auto i = _dependentMessages.find(item);
|
|
|
|
if (i == end(_dependentMessages)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const auto items = std::move(i->second);
|
|
|
|
_dependentMessages.erase(i);
|
|
|
|
|
|
|
|
for (const auto dependent : items) {
|
|
|
|
dependent->dependencyItemRemoved(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-25 12:45:15 +00:00
|
|
|
void Session::destroyMessage(not_null<HistoryItem*> item) {
|
|
|
|
Expects(!item->isLogEntry() || !item->mainView());
|
|
|
|
|
2019-04-30 08:04:42 +00:00
|
|
|
const auto peerId = item->history()->peer->id;
|
2019-04-25 12:45:15 +00:00
|
|
|
if (!item->isLogEntry()) {
|
|
|
|
// All this must be done for all items manually in History::clear()!
|
|
|
|
item->eraseFromUnreadMentions();
|
|
|
|
if (IsServerMsgId(item->id)) {
|
|
|
|
if (const auto types = item->sharedMediaTypes()) {
|
|
|
|
session().storage().remove(Storage::SharedMediaRemoveOne(
|
2019-04-30 08:04:42 +00:00
|
|
|
peerId,
|
2019-04-25 12:45:15 +00:00
|
|
|
types,
|
|
|
|
item->id));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
session().api().cancelLocalItem(item);
|
|
|
|
}
|
|
|
|
item->history()->itemRemoved(item);
|
|
|
|
}
|
2019-04-30 08:04:42 +00:00
|
|
|
_itemRemoved.fire_copy(item);
|
|
|
|
groups().unregisterMessage(item);
|
|
|
|
removeDependencyMessage(item);
|
|
|
|
session().notifications().clearFromItem(item);
|
|
|
|
|
|
|
|
const auto list = messagesListForInsert(peerToChannel(peerId));
|
2019-04-25 12:45:15 +00:00
|
|
|
list->erase(item->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
HistoryItem *Session::message(ChannelId channelId, MsgId itemId) const {
|
|
|
|
if (!itemId) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto data = messagesList(channelId);
|
|
|
|
if (!data) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto i = data->find(itemId);
|
|
|
|
return (i != data->end()) ? i->second.get() : nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
HistoryItem *Session::message(
|
|
|
|
const ChannelData *channel,
|
|
|
|
MsgId itemId) const {
|
|
|
|
return message(channel ? peerToChannel(channel->id) : 0, itemId);
|
|
|
|
}
|
|
|
|
|
|
|
|
HistoryItem *Session::message(FullMsgId itemId) const {
|
|
|
|
return message(itemId.channel, itemId.msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::updateDependentMessages(not_null<HistoryItem*> item) {
|
|
|
|
const auto i = _dependentMessages.find(item);
|
|
|
|
if (i != end(_dependentMessages)) {
|
|
|
|
for (const auto dependent : i->second) {
|
|
|
|
dependent->updateDependencyItem();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (App::main()) {
|
|
|
|
App::main()->itemEdited(item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerDependentMessage(
|
|
|
|
not_null<HistoryItem*> dependent,
|
|
|
|
not_null<HistoryItem*> dependency) {
|
|
|
|
_dependentMessages[dependency].emplace(dependent);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterDependentMessage(
|
|
|
|
not_null<HistoryItem*> dependent,
|
|
|
|
not_null<HistoryItem*> dependency) {
|
|
|
|
const auto i = _dependentMessages.find(dependency);
|
|
|
|
if (i != end(_dependentMessages)) {
|
|
|
|
if (i->second.remove(dependent) && i->second.empty()) {
|
|
|
|
_dependentMessages.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerMessageRandomId(uint64 randomId, FullMsgId itemId) {
|
|
|
|
_messageByRandomId.emplace(randomId, itemId);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterMessageRandomId(uint64 randomId) {
|
|
|
|
_messageByRandomId.remove(randomId);
|
|
|
|
}
|
|
|
|
|
|
|
|
FullMsgId Session::messageIdByRandomId(uint64 randomId) const {
|
|
|
|
const auto i = _messageByRandomId.find(randomId);
|
|
|
|
return (i != end(_messageByRandomId)) ? i->second : FullMsgId();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerMessageSentData(
|
|
|
|
uint64 randomId,
|
|
|
|
PeerId peerId,
|
|
|
|
const QString &text) {
|
|
|
|
_sentMessagesData.emplace(randomId, SentData{ peerId, text });
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterMessageSentData(uint64 randomId) {
|
|
|
|
_sentMessagesData.remove(randomId);
|
|
|
|
}
|
|
|
|
|
|
|
|
Session::SentData Session::messageSentData(uint64 randomId) const {
|
|
|
|
const auto i = _sentMessagesData.find(randomId);
|
|
|
|
return (i != end(_sentMessagesData)) ? i->second : SentData();
|
|
|
|
}
|
|
|
|
|
2018-04-09 17:48:29 +00:00
|
|
|
NotifySettings &Session::defaultNotifySettings(
|
|
|
|
not_null<const PeerData*> peer) {
|
|
|
|
return peer->isUser()
|
|
|
|
? _defaultUserNotifySettings
|
2019-06-04 13:40:24 +00:00
|
|
|
: (peer->isChat() || peer->isMegagroup())
|
|
|
|
? _defaultChatNotifySettings
|
|
|
|
: _defaultBroadcastNotifySettings;
|
2018-04-09 17:48:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const NotifySettings &Session::defaultNotifySettings(
|
|
|
|
not_null<const PeerData*> peer) const {
|
|
|
|
return peer->isUser()
|
|
|
|
? _defaultUserNotifySettings
|
2019-06-04 13:40:24 +00:00
|
|
|
: (peer->isChat() || peer->isMegagroup())
|
|
|
|
? _defaultChatNotifySettings
|
|
|
|
: _defaultBroadcastNotifySettings;
|
2018-04-09 17:48:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::updateNotifySettingsLocal(not_null<PeerData*> peer) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto history = historyLoaded(peer->id);
|
2019-02-19 06:57:53 +00:00
|
|
|
auto changesIn = crl::time(0);
|
2018-04-09 17:48:29 +00:00
|
|
|
const auto muted = notifyIsMuted(peer, &changesIn);
|
|
|
|
if (history && history->changeMute(muted)) {
|
|
|
|
// Notification already sent.
|
|
|
|
} else {
|
|
|
|
Notify::peerUpdatedDelayed(
|
|
|
|
peer,
|
|
|
|
Notify::PeerUpdate::Flag::NotificationsEnabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (muted) {
|
|
|
|
_mutedPeers.emplace(peer);
|
|
|
|
unmuteByFinishedDelayed(changesIn);
|
|
|
|
if (history) {
|
|
|
|
_session->notifications().clearFromHistory(history);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
_mutedPeers.erase(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-19 06:57:53 +00:00
|
|
|
void Session::unmuteByFinishedDelayed(crl::time delay) {
|
2018-08-01 16:58:50 +00:00
|
|
|
accumulate_min(delay, kMaxNotifyCheckDelay);
|
2018-04-09 17:48:29 +00:00
|
|
|
if (!_unmuteByFinishedTimer.isActive()
|
|
|
|
|| _unmuteByFinishedTimer.remainingTime() > delay) {
|
|
|
|
_unmuteByFinishedTimer.callOnce(delay);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unmuteByFinished() {
|
2019-02-19 06:57:53 +00:00
|
|
|
auto changesInMin = crl::time(0);
|
2018-04-09 17:48:29 +00:00
|
|
|
for (auto i = begin(_mutedPeers); i != end(_mutedPeers);) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto history = historyLoaded((*i)->id);
|
2019-02-19 06:57:53 +00:00
|
|
|
auto changesIn = crl::time(0);
|
2018-04-09 17:48:29 +00:00
|
|
|
const auto muted = notifyIsMuted(*i, &changesIn);
|
|
|
|
if (muted) {
|
|
|
|
if (history) {
|
|
|
|
history->changeMute(true);
|
|
|
|
}
|
|
|
|
if (!changesInMin || changesInMin > changesIn) {
|
|
|
|
changesInMin = changesIn;
|
|
|
|
}
|
|
|
|
++i;
|
|
|
|
} else {
|
|
|
|
if (history) {
|
|
|
|
history->changeMute(false);
|
|
|
|
}
|
|
|
|
i = _mutedPeers.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (changesInMin) {
|
|
|
|
unmuteByFinishedDelayed(changesInMin);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
HistoryItem *Session::addNewMessage(
|
|
|
|
const MTPMessage &data,
|
|
|
|
NewMessageType type) {
|
|
|
|
const auto peerId = PeerFromMessage(data);
|
|
|
|
if (!peerId) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto result = history(peerId)->addNewMessage(data, type);
|
2019-04-25 12:45:15 +00:00
|
|
|
if (result && type == NewMessageType::Unread) {
|
2019-01-03 12:36:01 +00:00
|
|
|
CheckForSwitchInlineButton(result);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Session::sendActionAnimationUpdated() const
|
|
|
|
-> rpl::producer<SendActionAnimationUpdate> {
|
|
|
|
return _sendActionAnimationUpdate.events();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::updateSendActionAnimation(
|
|
|
|
SendActionAnimationUpdate &&update) {
|
|
|
|
_sendActionAnimationUpdate.fire(std::move(update));
|
|
|
|
}
|
|
|
|
|
|
|
|
int Session::unreadBadge() const {
|
2019-04-24 15:28:01 +00:00
|
|
|
return computeUnreadBadge(_chatsList.unreadState());
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::unreadBadgeMuted() const {
|
2019-04-24 15:28:01 +00:00
|
|
|
return computeUnreadBadgeMuted(_chatsList.unreadState());
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-24 14:12:35 +00:00
|
|
|
int Session::unreadBadgeIgnoreOne(const Dialogs::Key &key) const {
|
|
|
|
const auto remove = (key && key.entry()->inChatList())
|
|
|
|
? key.entry()->chatListUnreadState()
|
|
|
|
: Dialogs::UnreadState();
|
2019-04-24 15:28:01 +00:00
|
|
|
return computeUnreadBadge(_chatsList.unreadState() - remove);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-24 14:12:35 +00:00
|
|
|
bool Session::unreadBadgeMutedIgnoreOne(const Dialogs::Key &key) const {
|
|
|
|
if (!_session->settings().includeMutedCounter()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
const auto remove = (key && key.entry()->inChatList())
|
|
|
|
? key.entry()->chatListUnreadState()
|
|
|
|
: Dialogs::UnreadState();
|
2019-04-24 15:28:01 +00:00
|
|
|
return computeUnreadBadgeMuted(_chatsList.unreadState() - remove);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int Session::unreadOnlyMutedBadge() const {
|
2019-04-22 14:22:39 +00:00
|
|
|
const auto state = _chatsList.unreadState();
|
2019-01-03 12:36:01 +00:00
|
|
|
return _session->settings().countUnreadMessages()
|
2019-04-24 15:28:01 +00:00
|
|
|
? state.messagesMuted
|
|
|
|
: state.chatsMuted;
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-24 15:28:01 +00:00
|
|
|
int Session::computeUnreadBadge(const Dialogs::UnreadState &state) const {
|
|
|
|
const auto all = _session->settings().includeMutedCounter();
|
|
|
|
return std::max(state.marks - (all ? 0 : state.marksMuted), 0)
|
|
|
|
+ (_session->settings().countUnreadMessages()
|
|
|
|
? std::max(state.messages - (all ? 0 : state.messagesMuted), 0)
|
|
|
|
: std::max(state.chats - (all ? 0 : state.chatsMuted), 0));
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::computeUnreadBadgeMuted(
|
2019-04-24 15:28:01 +00:00
|
|
|
const Dialogs::UnreadState &state) const {
|
2019-01-03 12:36:01 +00:00
|
|
|
if (!_session->settings().includeMutedCounter()) {
|
|
|
|
return false;
|
|
|
|
}
|
2019-04-24 15:28:01 +00:00
|
|
|
return (state.marksMuted >= state.marks)
|
|
|
|
&& (_session->settings().countUnreadMessages()
|
|
|
|
? (state.messagesMuted >= state.messages)
|
|
|
|
: (state.chatsMuted >= state.chats));
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
void Session::unreadStateChanged(
|
|
|
|
const Dialogs::Key &key,
|
|
|
|
const Dialogs::UnreadState &wasState) {
|
|
|
|
Expects(key.entry()->folderKnown());
|
|
|
|
Expects(key.entry()->inChatList());
|
2019-01-03 12:36:01 +00:00
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
const auto nowState = key.entry()->chatListUnreadState();
|
|
|
|
if (const auto folder = key.entry()->folder()) {
|
2019-04-23 12:29:23 +00:00
|
|
|
folder->unreadStateChanged(key, wasState, nowState);
|
2019-01-03 12:36:01 +00:00
|
|
|
} else {
|
2019-04-22 14:22:39 +00:00
|
|
|
_chatsList.unreadStateChanged(wasState, nowState);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
2019-04-22 14:22:39 +00:00
|
|
|
Notify::unreadCounterUpdated();
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
void Session::unreadEntryChanged(const Dialogs::Key &key, bool added) {
|
|
|
|
Expects(key.entry()->folderKnown());
|
|
|
|
|
|
|
|
const auto state = key.entry()->chatListUnreadState();
|
2019-04-23 12:29:23 +00:00
|
|
|
if (!state.empty()) {
|
|
|
|
if (const auto folder = key.entry()->folder()) {
|
|
|
|
folder->unreadEntryChanged(key, state, added);
|
|
|
|
} else {
|
|
|
|
_chatsList.unreadEntryChanged(state, added);
|
|
|
|
}
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-19 06:57:53 +00:00
|
|
|
void Session::selfDestructIn(not_null<HistoryItem*> item, crl::time delay) {
|
2019-01-03 12:36:01 +00:00
|
|
|
_selfDestructItems.push_back(item->fullId());
|
|
|
|
if (!_selfDestructTimer.isActive()
|
|
|
|
|| _selfDestructTimer.remainingTime() > delay) {
|
|
|
|
_selfDestructTimer.callOnce(delay);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::checkSelfDestructItems() {
|
2019-04-25 12:45:15 +00:00
|
|
|
const auto now = crl::now();
|
2019-02-19 06:57:53 +00:00
|
|
|
auto nextDestructIn = crl::time(0);
|
2019-01-03 12:36:01 +00:00
|
|
|
for (auto i = _selfDestructItems.begin(); i != _selfDestructItems.cend();) {
|
2019-04-25 12:45:15 +00:00
|
|
|
if (const auto item = message(*i)) {
|
2019-01-03 12:36:01 +00:00
|
|
|
if (auto destructIn = item->getSelfDestructIn(now)) {
|
|
|
|
if (nextDestructIn > 0) {
|
|
|
|
accumulate_min(nextDestructIn, destructIn);
|
|
|
|
} else {
|
|
|
|
nextDestructIn = destructIn;
|
|
|
|
}
|
|
|
|
++i;
|
|
|
|
} else {
|
|
|
|
i = _selfDestructItems.erase(i);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
i = _selfDestructItems.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (nextDestructIn > 0) {
|
|
|
|
_selfDestructTimer.callOnce(nextDestructIn);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
not_null<PhotoData*> Session::photo(PhotoId id) {
|
|
|
|
auto i = _photos.find(id);
|
|
|
|
if (i == _photos.end()) {
|
2019-01-25 14:37:28 +00:00
|
|
|
i = _photos.emplace(
|
|
|
|
id,
|
|
|
|
std::make_unique<PhotoData>(this, id)).first;
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<PhotoData*> Session::processPhoto(const MTPPhoto &data) {
|
2019-01-25 14:37:28 +00:00
|
|
|
return data.match([&](const MTPDphoto &data) {
|
|
|
|
return processPhoto(data);
|
|
|
|
}, [&](const MTPDphotoEmpty &data) {
|
|
|
|
return photo(data.vid.v);
|
|
|
|
});
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<PhotoData*> Session::processPhoto(const MTPDphoto &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto result = photo(data.vid.v);
|
|
|
|
photoApplyFields(result, data);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<PhotoData*> Session::processPhoto(
|
2018-01-17 16:21:01 +00:00
|
|
|
const MTPPhoto &data,
|
|
|
|
const PreparedPhotoThumbs &thumbs) {
|
2019-01-25 14:37:28 +00:00
|
|
|
Expects(!thumbs.empty());
|
|
|
|
|
|
|
|
const auto find = [&](const QByteArray &levels) {
|
|
|
|
const auto kInvalidIndex = int(levels.size());
|
|
|
|
const auto level = [&](const auto &pair) {
|
|
|
|
const auto letter = pair.first;
|
|
|
|
const auto index = levels.indexOf(letter);
|
|
|
|
return (index >= 0) ? index : kInvalidIndex;
|
|
|
|
};
|
|
|
|
const auto result = ranges::max_element(
|
|
|
|
thumbs,
|
|
|
|
std::greater<>(),
|
|
|
|
level);
|
|
|
|
return (level(*result) == kInvalidIndex) ? thumbs.end() : result;
|
|
|
|
};
|
|
|
|
const auto image = [&](const QByteArray &levels) {
|
|
|
|
const auto i = find(levels);
|
|
|
|
return (i == thumbs.end())
|
|
|
|
? ImagePtr()
|
|
|
|
: Images::Create(base::duplicate(i->second), "JPG");
|
|
|
|
};
|
|
|
|
const auto thumbnailInline = image(InlineLevels);
|
|
|
|
const auto thumbnailSmall = image(SmallLevels);
|
|
|
|
const auto thumbnail = image(ThumbnailLevels);
|
|
|
|
const auto large = image(LargeLevels);
|
|
|
|
return data.match([&](const MTPDphoto &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
return photo(
|
2019-01-25 14:37:28 +00:00
|
|
|
data.vid.v,
|
|
|
|
data.vaccess_hash.v,
|
|
|
|
data.vfile_reference.v,
|
|
|
|
data.vdate.v,
|
2019-03-22 14:19:43 +00:00
|
|
|
data.vdc_id.v,
|
2019-03-10 12:55:24 +00:00
|
|
|
data.is_has_stickers(),
|
2019-01-25 14:37:28 +00:00
|
|
|
thumbnailInline,
|
|
|
|
thumbnailSmall,
|
|
|
|
thumbnail,
|
|
|
|
large);
|
|
|
|
}, [&](const MTPDphotoEmpty &data) {
|
|
|
|
return photo(data.vid.v);
|
|
|
|
});
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
not_null<PhotoData*> Session::photo(
|
|
|
|
PhotoId id,
|
|
|
|
const uint64 &access,
|
2018-07-13 16:49:46 +00:00
|
|
|
const QByteArray &fileReference,
|
2018-01-17 16:21:01 +00:00
|
|
|
TimeId date,
|
2019-03-22 14:19:43 +00:00
|
|
|
int32 dc,
|
2019-03-10 12:55:24 +00:00
|
|
|
bool hasSticker,
|
2019-01-25 14:37:28 +00:00
|
|
|
const ImagePtr &thumbnailInline,
|
|
|
|
const ImagePtr &thumbnailSmall,
|
|
|
|
const ImagePtr &thumbnail,
|
|
|
|
const ImagePtr &large) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto result = photo(id);
|
|
|
|
photoApplyFields(
|
|
|
|
result,
|
|
|
|
access,
|
2018-07-13 16:49:46 +00:00
|
|
|
fileReference,
|
2018-01-17 16:21:01 +00:00
|
|
|
date,
|
2019-03-22 14:19:43 +00:00
|
|
|
dc,
|
2019-03-10 12:55:24 +00:00
|
|
|
hasSticker,
|
2019-01-25 14:37:28 +00:00
|
|
|
thumbnailInline,
|
|
|
|
thumbnailSmall,
|
|
|
|
thumbnail,
|
|
|
|
large);
|
2018-01-17 16:21:01 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::photoConvert(
|
|
|
|
not_null<PhotoData*> original,
|
|
|
|
const MTPPhoto &data) {
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto id = data.match([](const auto &data) {
|
|
|
|
return data.vid.v;
|
|
|
|
});
|
2018-01-17 16:21:01 +00:00
|
|
|
if (original->id != id) {
|
|
|
|
auto i = _photos.find(id);
|
|
|
|
if (i == _photos.end()) {
|
|
|
|
const auto j = _photos.find(original->id);
|
|
|
|
Assert(j != _photos.end());
|
|
|
|
auto owned = std::move(j->second);
|
|
|
|
_photos.erase(j);
|
|
|
|
i = _photos.emplace(id, std::move(owned)).first;
|
|
|
|
}
|
|
|
|
|
|
|
|
original->id = id;
|
|
|
|
original->uploadingData = nullptr;
|
|
|
|
|
|
|
|
if (i->second.get() != original) {
|
|
|
|
photoApplyFields(i->second.get(), data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
photoApplyFields(original, data);
|
|
|
|
}
|
|
|
|
|
2018-03-04 20:04:13 +00:00
|
|
|
PhotoData *Session::photoFromWeb(
|
|
|
|
const MTPWebDocument &data,
|
2019-03-12 09:49:16 +00:00
|
|
|
ImagePtr thumbnail,
|
2018-10-23 09:08:50 +00:00
|
|
|
bool willBecomeNormal) {
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto large = Images::Create(data);
|
|
|
|
const auto thumbnailInline = ImagePtr();
|
|
|
|
if (large->isNull()) {
|
2018-03-04 20:04:13 +00:00
|
|
|
return nullptr;
|
|
|
|
}
|
2019-03-12 09:49:16 +00:00
|
|
|
auto thumbnailSmall = large;
|
2018-10-23 09:08:50 +00:00
|
|
|
if (willBecomeNormal) {
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto width = large->width();
|
|
|
|
const auto height = large->height();
|
2018-03-04 20:04:13 +00:00
|
|
|
|
2019-03-12 09:49:16 +00:00
|
|
|
auto thumbsize = shrinkToKeepAspect(width, height, 100, 100);
|
|
|
|
thumbnailSmall = Images::Create(thumbsize.width(), thumbsize.height());
|
|
|
|
|
|
|
|
if (thumbnail->isNull()) {
|
|
|
|
auto mediumsize = shrinkToKeepAspect(width, height, 320, 320);
|
|
|
|
thumbnail = Images::Create(mediumsize.width(), mediumsize.height());
|
|
|
|
}
|
|
|
|
} else if (thumbnail->isNull()) {
|
|
|
|
thumbnail = large;
|
2018-10-23 09:08:50 +00:00
|
|
|
}
|
2018-03-04 20:04:13 +00:00
|
|
|
|
|
|
|
return photo(
|
|
|
|
rand_value<PhotoId>(),
|
|
|
|
uint64(0),
|
2018-07-13 16:49:46 +00:00
|
|
|
QByteArray(),
|
2018-03-04 20:04:13 +00:00
|
|
|
unixtime(),
|
2019-03-22 14:19:43 +00:00
|
|
|
0,
|
2019-03-10 12:55:24 +00:00
|
|
|
false,
|
2019-01-25 14:37:28 +00:00
|
|
|
thumbnailInline,
|
|
|
|
thumbnailSmall,
|
|
|
|
thumbnail,
|
|
|
|
large);
|
2018-03-04 20:04:13 +00:00
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Session::photoApplyFields(
|
|
|
|
not_null<PhotoData*> photo,
|
|
|
|
const MTPPhoto &data) {
|
|
|
|
if (data.type() == mtpc_photo) {
|
|
|
|
photoApplyFields(photo, data.c_photo());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::photoApplyFields(
|
|
|
|
not_null<PhotoData*> photo,
|
|
|
|
const MTPDphoto &data) {
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto &sizes = data.vsizes.v;
|
|
|
|
const auto find = [&](const QByteArray &levels) {
|
|
|
|
const auto kInvalidIndex = int(levels.size());
|
|
|
|
const auto level = [&](const MTPPhotoSize &size) {
|
|
|
|
const auto letter = size.match([](const MTPDphotoSizeEmpty &) {
|
|
|
|
return char(0);
|
|
|
|
}, [](const auto &size) {
|
|
|
|
return size.vtype.v.isEmpty() ? char(0) : size.vtype.v[0];
|
|
|
|
});
|
|
|
|
const auto index = levels.indexOf(letter);
|
|
|
|
return (index >= 0) ? index : kInvalidIndex;
|
|
|
|
};
|
|
|
|
const auto result = ranges::max_element(
|
|
|
|
sizes,
|
|
|
|
std::greater<>(),
|
|
|
|
level);
|
|
|
|
return (level(*result) == kInvalidIndex) ? sizes.end() : result;
|
|
|
|
};
|
|
|
|
const auto image = [&](const QByteArray &levels) {
|
|
|
|
const auto i = find(levels);
|
2019-03-22 14:19:43 +00:00
|
|
|
return (i == sizes.end()) ? ImagePtr() : Images::Create(data, *i);
|
2019-01-25 14:37:28 +00:00
|
|
|
};
|
|
|
|
const auto thumbnailInline = image(InlineLevels);
|
|
|
|
const auto thumbnailSmall = image(SmallLevels);
|
|
|
|
const auto thumbnail = image(ThumbnailLevels);
|
|
|
|
const auto large = image(LargeLevels);
|
|
|
|
if (thumbnailSmall && thumbnail && large) {
|
2018-01-17 16:21:01 +00:00
|
|
|
photoApplyFields(
|
|
|
|
photo,
|
|
|
|
data.vaccess_hash.v,
|
2018-07-13 16:49:46 +00:00
|
|
|
data.vfile_reference.v,
|
2018-01-17 16:21:01 +00:00
|
|
|
data.vdate.v,
|
2019-03-22 14:19:43 +00:00
|
|
|
data.vdc_id.v,
|
2019-03-10 12:55:24 +00:00
|
|
|
data.is_has_stickers(),
|
2019-01-25 14:37:28 +00:00
|
|
|
thumbnailInline,
|
|
|
|
thumbnailSmall,
|
|
|
|
thumbnail,
|
|
|
|
large);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::photoApplyFields(
|
|
|
|
not_null<PhotoData*> photo,
|
|
|
|
const uint64 &access,
|
2018-07-13 16:49:46 +00:00
|
|
|
const QByteArray &fileReference,
|
2018-01-17 16:21:01 +00:00
|
|
|
TimeId date,
|
2019-03-22 14:19:43 +00:00
|
|
|
int32 dc,
|
2019-03-10 12:55:24 +00:00
|
|
|
bool hasSticker,
|
2019-01-25 14:37:28 +00:00
|
|
|
const ImagePtr &thumbnailInline,
|
|
|
|
const ImagePtr &thumbnailSmall,
|
|
|
|
const ImagePtr &thumbnail,
|
|
|
|
const ImagePtr &large) {
|
2018-01-17 16:21:01 +00:00
|
|
|
if (!date) {
|
|
|
|
return;
|
|
|
|
}
|
2019-03-22 14:19:43 +00:00
|
|
|
photo->setRemoteLocation(dc, access, fileReference);
|
2018-01-17 16:21:01 +00:00
|
|
|
photo->date = date;
|
2019-03-10 12:55:24 +00:00
|
|
|
photo->hasSticker = hasSticker;
|
2019-01-25 14:37:28 +00:00
|
|
|
photo->updateImages(
|
|
|
|
thumbnailInline,
|
|
|
|
thumbnailSmall,
|
|
|
|
thumbnail,
|
|
|
|
large);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
not_null<DocumentData*> Session::document(DocumentId id) {
|
|
|
|
auto i = _documents.find(id);
|
|
|
|
if (i == _documents.cend()) {
|
2018-01-27 09:21:57 +00:00
|
|
|
i = _documents.emplace(
|
|
|
|
id,
|
2019-01-25 14:37:28 +00:00
|
|
|
std::make_unique<DocumentData>(this, id)).first;
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<DocumentData*> Session::processDocument(const MTPDocument &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
switch (data.type()) {
|
|
|
|
case mtpc_document:
|
2019-01-18 12:27:37 +00:00
|
|
|
return processDocument(data.c_document());
|
2018-01-17 16:21:01 +00:00
|
|
|
|
|
|
|
case mtpc_documentEmpty:
|
|
|
|
return document(data.c_documentEmpty().vid.v);
|
|
|
|
}
|
|
|
|
Unexpected("Type in Session::document().");
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<DocumentData*> Session::processDocument(const MTPDdocument &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto result = document(data.vid.v);
|
|
|
|
documentApplyFields(result, data);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<DocumentData*> Session::processDocument(
|
2018-01-17 16:21:01 +00:00
|
|
|
const MTPdocument &data,
|
2018-10-12 16:41:51 +00:00
|
|
|
QImage &&thumb) {
|
2018-01-17 16:21:01 +00:00
|
|
|
switch (data.type()) {
|
|
|
|
case mtpc_documentEmpty:
|
|
|
|
return document(data.c_documentEmpty().vid.v);
|
|
|
|
|
|
|
|
case mtpc_document: {
|
|
|
|
const auto &fields = data.c_document();
|
|
|
|
return document(
|
|
|
|
fields.vid.v,
|
|
|
|
fields.vaccess_hash.v,
|
2018-07-13 16:49:46 +00:00
|
|
|
fields.vfile_reference.v,
|
2018-01-17 16:21:01 +00:00
|
|
|
fields.vdate.v,
|
|
|
|
fields.vattributes.v,
|
|
|
|
qs(fields.vmime_type),
|
2019-01-25 14:37:28 +00:00
|
|
|
ImagePtr(),
|
2018-10-23 09:08:50 +00:00
|
|
|
Images::Create(std::move(thumb), "JPG"),
|
2018-01-17 16:21:01 +00:00
|
|
|
fields.vdc_id.v,
|
|
|
|
fields.vsize.v,
|
|
|
|
StorageImageLocation());
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
Unexpected("Type in Session::document() with thumb.");
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<DocumentData*> Session::document(
|
|
|
|
DocumentId id,
|
|
|
|
const uint64 &access,
|
2018-07-13 16:49:46 +00:00
|
|
|
const QByteArray &fileReference,
|
2018-01-17 16:21:01 +00:00
|
|
|
TimeId date,
|
|
|
|
const QVector<MTPDocumentAttribute> &attributes,
|
|
|
|
const QString &mime,
|
2019-01-25 14:37:28 +00:00
|
|
|
const ImagePtr &thumbnailInline,
|
|
|
|
const ImagePtr &thumbnail,
|
2018-01-17 16:21:01 +00:00
|
|
|
int32 dc,
|
|
|
|
int32 size,
|
|
|
|
const StorageImageLocation &thumbLocation) {
|
|
|
|
const auto result = document(id);
|
|
|
|
documentApplyFields(
|
|
|
|
result,
|
|
|
|
access,
|
2018-07-13 16:49:46 +00:00
|
|
|
fileReference,
|
2018-01-17 16:21:01 +00:00
|
|
|
date,
|
|
|
|
attributes,
|
|
|
|
mime,
|
2019-01-25 14:37:28 +00:00
|
|
|
thumbnailInline,
|
|
|
|
thumbnail,
|
2018-01-17 16:21:01 +00:00
|
|
|
dc,
|
|
|
|
size,
|
|
|
|
thumbLocation);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::documentConvert(
|
|
|
|
not_null<DocumentData*> original,
|
|
|
|
const MTPDocument &data) {
|
|
|
|
const auto id = [&] {
|
|
|
|
switch (data.type()) {
|
|
|
|
case mtpc_document: return data.c_document().vid.v;
|
|
|
|
case mtpc_documentEmpty: return data.c_documentEmpty().vid.v;
|
|
|
|
}
|
|
|
|
Unexpected("Type in Session::documentConvert().");
|
|
|
|
}();
|
|
|
|
const auto oldKey = original->mediaKey();
|
2018-08-27 11:35:58 +00:00
|
|
|
const auto oldCacheKey = original->cacheKey();
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto idChanged = (original->id != id);
|
|
|
|
const auto sentSticker = idChanged && (original->sticker() != nullptr);
|
|
|
|
if (idChanged) {
|
|
|
|
auto i = _documents.find(id);
|
|
|
|
if (i == _documents.end()) {
|
|
|
|
const auto j = _documents.find(original->id);
|
|
|
|
Assert(j != _documents.end());
|
|
|
|
auto owned = std::move(j->second);
|
|
|
|
_documents.erase(j);
|
|
|
|
i = _documents.emplace(id, std::move(owned)).first;
|
|
|
|
}
|
|
|
|
|
|
|
|
original->id = id;
|
|
|
|
original->status = FileReady;
|
|
|
|
original->uploadingData = nullptr;
|
|
|
|
|
|
|
|
if (i->second.get() != original) {
|
|
|
|
documentApplyFields(i->second.get(), data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
documentApplyFields(original, data);
|
|
|
|
if (idChanged) {
|
2018-08-27 11:35:58 +00:00
|
|
|
cache().moveIfEmpty(oldCacheKey, original->cacheKey());
|
2018-01-17 16:21:01 +00:00
|
|
|
if (savedGifs().indexOf(original) >= 0) {
|
|
|
|
Local::writeSavedGifs();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-04 20:04:13 +00:00
|
|
|
DocumentData *Session::documentFromWeb(
|
|
|
|
const MTPWebDocument &data,
|
|
|
|
ImagePtr thumb) {
|
|
|
|
switch (data.type()) {
|
|
|
|
case mtpc_webDocument:
|
|
|
|
return documentFromWeb(data.c_webDocument(), thumb);
|
|
|
|
|
|
|
|
case mtpc_webDocumentNoProxy:
|
|
|
|
return documentFromWeb(data.c_webDocumentNoProxy(), thumb);
|
|
|
|
|
|
|
|
}
|
|
|
|
Unexpected("Type in Session::documentFromWeb.");
|
|
|
|
}
|
|
|
|
|
|
|
|
DocumentData *Session::documentFromWeb(
|
|
|
|
const MTPDwebDocument &data,
|
|
|
|
ImagePtr thumb) {
|
|
|
|
const auto result = document(
|
|
|
|
rand_value<DocumentId>(),
|
|
|
|
uint64(0),
|
2018-07-13 16:49:46 +00:00
|
|
|
QByteArray(),
|
2018-03-04 20:04:13 +00:00
|
|
|
unixtime(),
|
|
|
|
data.vattributes.v,
|
|
|
|
data.vmime_type.v,
|
2019-01-25 14:37:28 +00:00
|
|
|
ImagePtr(),
|
2018-03-04 20:04:13 +00:00
|
|
|
thumb,
|
|
|
|
MTP::maindc(),
|
|
|
|
int32(0), // data.vsize.v
|
|
|
|
StorageImageLocation());
|
|
|
|
result->setWebLocation(WebFileLocation(
|
|
|
|
data.vurl.v,
|
|
|
|
data.vaccess_hash.v));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
DocumentData *Session::documentFromWeb(
|
|
|
|
const MTPDwebDocumentNoProxy &data,
|
|
|
|
ImagePtr thumb) {
|
|
|
|
const auto result = document(
|
|
|
|
rand_value<DocumentId>(),
|
|
|
|
uint64(0),
|
2018-07-13 16:49:46 +00:00
|
|
|
QByteArray(),
|
2018-03-04 20:04:13 +00:00
|
|
|
unixtime(),
|
|
|
|
data.vattributes.v,
|
|
|
|
data.vmime_type.v,
|
2019-01-25 14:37:28 +00:00
|
|
|
ImagePtr(),
|
2018-03-04 20:04:13 +00:00
|
|
|
thumb,
|
|
|
|
MTP::maindc(),
|
|
|
|
int32(0), // data.vsize.v
|
|
|
|
StorageImageLocation());
|
|
|
|
result->setContentUrl(qs(data.vurl));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Session::documentApplyFields(
|
|
|
|
not_null<DocumentData*> document,
|
|
|
|
const MTPDocument &data) {
|
|
|
|
if (data.type() == mtpc_document) {
|
|
|
|
documentApplyFields(document, data.c_document());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::documentApplyFields(
|
|
|
|
not_null<DocumentData*> document,
|
|
|
|
const MTPDdocument &data) {
|
2019-01-25 14:37:28 +00:00
|
|
|
const auto thumbnailInline = FindDocumentInlineThumbnail(data);
|
2019-03-22 14:19:43 +00:00
|
|
|
const auto thumbnailSize = FindDocumentThumbnail(data);
|
|
|
|
const auto thumbnail = Images::Create(data, thumbnailSize);
|
2018-01-17 16:21:01 +00:00
|
|
|
documentApplyFields(
|
|
|
|
document,
|
|
|
|
data.vaccess_hash.v,
|
2018-07-13 16:49:46 +00:00
|
|
|
data.vfile_reference.v,
|
2018-01-17 16:21:01 +00:00
|
|
|
data.vdate.v,
|
|
|
|
data.vattributes.v,
|
|
|
|
qs(data.vmime_type),
|
2019-03-22 14:19:43 +00:00
|
|
|
Images::Create(data, thumbnailInline),
|
|
|
|
thumbnail,
|
2018-01-17 16:21:01 +00:00
|
|
|
data.vdc_id.v,
|
|
|
|
data.vsize.v,
|
2019-03-22 14:19:43 +00:00
|
|
|
thumbnail->location());
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::documentApplyFields(
|
|
|
|
not_null<DocumentData*> document,
|
|
|
|
const uint64 &access,
|
2018-07-13 16:49:46 +00:00
|
|
|
const QByteArray &fileReference,
|
2018-01-17 16:21:01 +00:00
|
|
|
TimeId date,
|
|
|
|
const QVector<MTPDocumentAttribute> &attributes,
|
|
|
|
const QString &mime,
|
2019-01-25 14:37:28 +00:00
|
|
|
const ImagePtr &thumbnailInline,
|
|
|
|
const ImagePtr &thumbnail,
|
2018-01-17 16:21:01 +00:00
|
|
|
int32 dc,
|
|
|
|
int32 size,
|
|
|
|
const StorageImageLocation &thumbLocation) {
|
|
|
|
if (!date) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
document->date = date;
|
|
|
|
document->setMimeString(mime);
|
2019-01-25 14:37:28 +00:00
|
|
|
document->updateThumbnails(thumbnailInline, thumbnail);
|
2018-01-17 16:21:01 +00:00
|
|
|
document->size = size;
|
2019-05-27 12:57:26 +00:00
|
|
|
document->setattributes(attributes);
|
2019-05-31 16:45:03 +00:00
|
|
|
|
|
|
|
// Uses 'type' that is computed from attributes.
|
|
|
|
document->recountIsImage();
|
|
|
|
if (dc != 0 && access != 0) {
|
|
|
|
document->setRemoteLocation(dc, access, fileReference);
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
if (document->sticker()
|
2019-03-22 14:19:43 +00:00
|
|
|
&& !document->sticker()->loc.valid()
|
|
|
|
&& thumbLocation.valid()) {
|
2018-01-17 16:21:01 +00:00
|
|
|
document->sticker()->loc = thumbLocation;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<WebPageData*> Session::webpage(WebPageId id) {
|
|
|
|
auto i = _webpages.find(id);
|
|
|
|
if (i == _webpages.cend()) {
|
|
|
|
i = _webpages.emplace(id, std::make_unique<WebPageData>(id)).first;
|
|
|
|
}
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<WebPageData*> Session::processWebpage(const MTPWebPage &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
switch (data.type()) {
|
|
|
|
case mtpc_webPage:
|
2019-01-18 12:27:37 +00:00
|
|
|
return processWebpage(data.c_webPage());
|
2018-01-17 16:21:01 +00:00
|
|
|
case mtpc_webPageEmpty: {
|
|
|
|
const auto result = webpage(data.c_webPageEmpty().vid.v);
|
|
|
|
if (result->pendingTill > 0) {
|
|
|
|
result->pendingTill = -1; // failed
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} break;
|
|
|
|
case mtpc_webPagePending:
|
2019-01-18 12:27:37 +00:00
|
|
|
return processWebpage(data.c_webPagePending());
|
2018-01-17 16:21:01 +00:00
|
|
|
case mtpc_webPageNotModified:
|
|
|
|
LOG(("API Error: "
|
|
|
|
"webPageNotModified is unexpected in Session::webpage()."));
|
|
|
|
return webpage(0);
|
|
|
|
}
|
|
|
|
Unexpected("Type in Session::webpage().");
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<WebPageData*> Session::processWebpage(const MTPDwebPage &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto result = webpage(data.vid.v);
|
|
|
|
webpageApplyFields(result, data);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<WebPageData*> Session::processWebpage(const MTPDwebPagePending &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
constexpr auto kDefaultPendingTimeout = 60;
|
|
|
|
const auto result = webpage(data.vid.v);
|
|
|
|
webpageApplyFields(
|
|
|
|
result,
|
2018-10-31 10:11:01 +00:00
|
|
|
WebPageType::Article,
|
2018-01-17 16:21:01 +00:00
|
|
|
QString(),
|
|
|
|
QString(),
|
|
|
|
QString(),
|
|
|
|
QString(),
|
|
|
|
TextWithEntities(),
|
|
|
|
nullptr,
|
|
|
|
nullptr,
|
2018-10-24 11:52:31 +00:00
|
|
|
WebPageCollage(),
|
2018-01-17 16:21:01 +00:00
|
|
|
0,
|
|
|
|
QString(),
|
|
|
|
data.vdate.v
|
|
|
|
? data.vdate.v
|
|
|
|
: (unixtime() + kDefaultPendingTimeout));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<WebPageData*> Session::webpage(
|
|
|
|
WebPageId id,
|
|
|
|
const QString &siteName,
|
|
|
|
const TextWithEntities &content) {
|
|
|
|
return webpage(
|
|
|
|
id,
|
2018-10-31 10:11:01 +00:00
|
|
|
WebPageType::Article,
|
2018-01-17 16:21:01 +00:00
|
|
|
QString(),
|
|
|
|
QString(),
|
|
|
|
siteName,
|
|
|
|
QString(),
|
|
|
|
content,
|
|
|
|
nullptr,
|
|
|
|
nullptr,
|
2018-10-24 11:52:31 +00:00
|
|
|
WebPageCollage(),
|
2018-01-17 16:21:01 +00:00
|
|
|
0,
|
|
|
|
QString(),
|
|
|
|
TimeId(0));
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<WebPageData*> Session::webpage(
|
|
|
|
WebPageId id,
|
2018-10-31 10:11:01 +00:00
|
|
|
WebPageType type,
|
2018-01-17 16:21:01 +00:00
|
|
|
const QString &url,
|
|
|
|
const QString &displayUrl,
|
|
|
|
const QString &siteName,
|
|
|
|
const QString &title,
|
|
|
|
const TextWithEntities &description,
|
|
|
|
PhotoData *photo,
|
|
|
|
DocumentData *document,
|
2018-10-24 11:52:31 +00:00
|
|
|
WebPageCollage &&collage,
|
2018-01-17 16:21:01 +00:00
|
|
|
int duration,
|
|
|
|
const QString &author,
|
|
|
|
TimeId pendingTill) {
|
|
|
|
const auto result = webpage(id);
|
|
|
|
webpageApplyFields(
|
|
|
|
result,
|
|
|
|
type,
|
|
|
|
url,
|
|
|
|
displayUrl,
|
|
|
|
siteName,
|
|
|
|
title,
|
|
|
|
description,
|
|
|
|
photo,
|
|
|
|
document,
|
2018-10-24 11:52:31 +00:00
|
|
|
std::move(collage),
|
2018-01-17 16:21:01 +00:00
|
|
|
duration,
|
|
|
|
author,
|
|
|
|
pendingTill);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::webpageApplyFields(
|
|
|
|
not_null<WebPageData*> page,
|
|
|
|
const MTPDwebPage &data) {
|
|
|
|
auto description = TextWithEntities {
|
|
|
|
data.has_description()
|
|
|
|
? TextUtilities::Clean(qs(data.vdescription))
|
|
|
|
: QString()
|
|
|
|
};
|
|
|
|
const auto siteName = data.has_site_name()
|
|
|
|
? qs(data.vsite_name)
|
|
|
|
: QString();
|
|
|
|
auto parseFlags = TextParseLinks | TextParseMultiline | TextParseRichText;
|
|
|
|
if (siteName == qstr("Twitter") || siteName == qstr("Instagram")) {
|
|
|
|
parseFlags |= TextParseHashtags | TextParseMentions;
|
|
|
|
}
|
|
|
|
TextUtilities::ParseEntities(description, parseFlags);
|
|
|
|
const auto pendingTill = TimeId(0);
|
|
|
|
webpageApplyFields(
|
|
|
|
page,
|
2018-10-31 10:11:01 +00:00
|
|
|
ParseWebPageType(data),
|
2018-01-17 16:21:01 +00:00
|
|
|
qs(data.vurl),
|
|
|
|
qs(data.vdisplay_url),
|
|
|
|
siteName,
|
|
|
|
data.has_title() ? qs(data.vtitle) : QString(),
|
|
|
|
description,
|
2019-01-18 12:27:37 +00:00
|
|
|
data.has_photo() ? processPhoto(data.vphoto).get() : nullptr,
|
|
|
|
(data.has_document()
|
|
|
|
? processDocument(data.vdocument).get()
|
|
|
|
: nullptr),
|
2018-10-24 11:52:31 +00:00
|
|
|
WebPageCollage(data),
|
2018-01-17 16:21:01 +00:00
|
|
|
data.has_duration() ? data.vduration.v : 0,
|
|
|
|
data.has_author() ? qs(data.vauthor) : QString(),
|
|
|
|
pendingTill);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::webpageApplyFields(
|
|
|
|
not_null<WebPageData*> page,
|
2018-10-31 10:11:01 +00:00
|
|
|
WebPageType type,
|
2018-01-17 16:21:01 +00:00
|
|
|
const QString &url,
|
|
|
|
const QString &displayUrl,
|
|
|
|
const QString &siteName,
|
|
|
|
const QString &title,
|
|
|
|
const TextWithEntities &description,
|
|
|
|
PhotoData *photo,
|
|
|
|
DocumentData *document,
|
2018-10-24 11:52:31 +00:00
|
|
|
WebPageCollage &&collage,
|
2018-01-17 16:21:01 +00:00
|
|
|
int duration,
|
|
|
|
const QString &author,
|
|
|
|
TimeId pendingTill) {
|
2018-07-25 16:01:09 +00:00
|
|
|
const auto requestPending = (!page->pendingTill && pendingTill > 0);
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto changed = page->applyChanges(
|
|
|
|
type,
|
|
|
|
url,
|
|
|
|
displayUrl,
|
|
|
|
siteName,
|
|
|
|
title,
|
|
|
|
description,
|
|
|
|
photo,
|
|
|
|
document,
|
2018-10-24 11:52:31 +00:00
|
|
|
std::move(collage),
|
2018-01-17 16:21:01 +00:00
|
|
|
duration,
|
|
|
|
author,
|
|
|
|
pendingTill);
|
2018-07-25 16:01:09 +00:00
|
|
|
if (requestPending) {
|
|
|
|
_session->api().requestWebPageDelayed(page);
|
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
if (changed) {
|
|
|
|
notifyWebPageUpdateDelayed(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<GameData*> Session::game(GameId id) {
|
|
|
|
auto i = _games.find(id);
|
|
|
|
if (i == _games.cend()) {
|
|
|
|
i = _games.emplace(id, std::make_unique<GameData>(id)).first;
|
|
|
|
}
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<GameData*> Session::processGame(const MTPDgame &data) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto result = game(data.vid.v);
|
|
|
|
gameApplyFields(result, data);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<GameData*> Session::game(
|
|
|
|
GameId id,
|
|
|
|
const uint64 &accessHash,
|
|
|
|
const QString &shortName,
|
|
|
|
const QString &title,
|
|
|
|
const QString &description,
|
|
|
|
PhotoData *photo,
|
|
|
|
DocumentData *document) {
|
|
|
|
const auto result = game(id);
|
|
|
|
gameApplyFields(
|
|
|
|
result,
|
|
|
|
accessHash,
|
|
|
|
shortName,
|
|
|
|
title,
|
|
|
|
description,
|
|
|
|
photo,
|
|
|
|
document);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::gameConvert(
|
|
|
|
not_null<GameData*> original,
|
|
|
|
const MTPGame &data) {
|
|
|
|
Expects(data.type() == mtpc_game);
|
|
|
|
|
|
|
|
const auto id = data.c_game().vid.v;
|
|
|
|
if (original->id != id) {
|
|
|
|
auto i = _games.find(id);
|
|
|
|
if (i == _games.end()) {
|
|
|
|
const auto j = _games.find(original->id);
|
|
|
|
Assert(j != _games.end());
|
|
|
|
auto owned = std::move(j->second);
|
|
|
|
_games.erase(j);
|
|
|
|
i = _games.emplace(id, std::move(owned)).first;
|
|
|
|
}
|
|
|
|
|
|
|
|
original->id = id;
|
|
|
|
original->accessHash = 0;
|
|
|
|
|
|
|
|
if (i->second.get() != original) {
|
|
|
|
gameApplyFields(i->second.get(), data.c_game());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
gameApplyFields(original, data.c_game());
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::gameApplyFields(
|
|
|
|
not_null<GameData*> game,
|
|
|
|
const MTPDgame &data) {
|
|
|
|
gameApplyFields(
|
|
|
|
game,
|
|
|
|
data.vaccess_hash.v,
|
|
|
|
qs(data.vshort_name),
|
|
|
|
qs(data.vtitle),
|
|
|
|
qs(data.vdescription),
|
2019-01-18 12:27:37 +00:00
|
|
|
processPhoto(data.vphoto),
|
|
|
|
(data.has_document()
|
|
|
|
? processDocument(data.vdocument).get()
|
|
|
|
: nullptr));
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Session::gameApplyFields(
|
|
|
|
not_null<GameData*> game,
|
|
|
|
const uint64 &accessHash,
|
|
|
|
const QString &shortName,
|
|
|
|
const QString &title,
|
|
|
|
const QString &description,
|
|
|
|
PhotoData *photo,
|
|
|
|
DocumentData *document) {
|
2018-04-07 07:41:48 +00:00
|
|
|
if (game->accessHash) {
|
2018-01-17 16:21:01 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
game->accessHash = accessHash;
|
|
|
|
game->shortName = TextUtilities::Clean(shortName);
|
|
|
|
game->title = TextUtilities::SingleLine(title);
|
|
|
|
game->description = TextUtilities::Clean(description);
|
|
|
|
game->photo = photo;
|
|
|
|
game->document = document;
|
|
|
|
notifyGameUpdateDelayed(game);
|
|
|
|
}
|
|
|
|
|
2018-12-18 05:43:11 +00:00
|
|
|
not_null<PollData*> Session::poll(PollId id) {
|
|
|
|
auto i = _polls.find(id);
|
|
|
|
if (i == _polls.cend()) {
|
|
|
|
i = _polls.emplace(id, std::make_unique<PollData>(id)).first;
|
|
|
|
}
|
|
|
|
return i->second.get();
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<PollData*> Session::processPoll(const MTPPoll &data) {
|
2018-12-18 05:43:11 +00:00
|
|
|
return data.match([&](const MTPDpoll &data) {
|
|
|
|
const auto id = data.vid.v;
|
|
|
|
const auto result = poll(id);
|
|
|
|
const auto changed = result->applyChanges(data);
|
|
|
|
if (changed) {
|
|
|
|
notifyPollUpdateDelayed(result);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-01-18 12:27:37 +00:00
|
|
|
not_null<PollData*> Session::processPoll(const MTPDmessageMediaPoll &data) {
|
|
|
|
const auto result = processPoll(data.vpoll);
|
2018-12-18 05:43:11 +00:00
|
|
|
const auto changed = result->applyResults(data.vresults);
|
|
|
|
if (changed) {
|
2018-12-25 14:17:02 +00:00
|
|
|
notifyPollUpdateDelayed(result);
|
2018-12-18 05:43:11 +00:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-01-13 08:03:34 +00:00
|
|
|
void Session::applyUpdate(const MTPDupdateMessagePoll &update) {
|
2018-12-18 13:56:38 +00:00
|
|
|
const auto updated = [&] {
|
|
|
|
const auto i = _polls.find(update.vpoll_id.v);
|
|
|
|
return (i == end(_polls))
|
|
|
|
? nullptr
|
|
|
|
: update.has_poll()
|
2019-01-18 12:27:37 +00:00
|
|
|
? processPoll(update.vpoll).get()
|
2018-12-18 13:56:38 +00:00
|
|
|
: i->second.get();
|
2018-12-18 05:43:11 +00:00
|
|
|
}();
|
2018-12-18 13:56:38 +00:00
|
|
|
if (updated && updated->applyResults(update.vresults)) {
|
2018-12-25 14:17:02 +00:00
|
|
|
notifyPollUpdateDelayed(updated);
|
2018-12-18 05:43:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-13 08:03:34 +00:00
|
|
|
void Session::applyUpdate(const MTPDupdateChatParticipants &update) {
|
|
|
|
const auto chatId = update.vparticipants.match([](const auto &update) {
|
|
|
|
return update.vchat_id.v;
|
|
|
|
});
|
|
|
|
if (const auto chat = chatLoaded(chatId)) {
|
|
|
|
ApplyChatUpdate(chat, update);
|
|
|
|
for (const auto user : chat->participants) {
|
|
|
|
if (user->botInfo && !user->botInfo->inited) {
|
|
|
|
_session->api().requestFullPeer(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::applyUpdate(const MTPDupdateChatParticipantAdd &update) {
|
|
|
|
if (const auto chat = chatLoaded(update.vchat_id.v)) {
|
|
|
|
ApplyChatUpdate(chat, update);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::applyUpdate(const MTPDupdateChatParticipantDelete &update) {
|
|
|
|
if (const auto chat = chatLoaded(update.vchat_id.v)) {
|
|
|
|
ApplyChatUpdate(chat, update);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::applyUpdate(const MTPDupdateChatParticipantAdmin &update) {
|
|
|
|
if (const auto chat = chatLoaded(update.vchat_id.v)) {
|
|
|
|
ApplyChatUpdate(chat, update);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::applyUpdate(const MTPDupdateChatDefaultBannedRights &update) {
|
|
|
|
if (const auto peer = peerLoaded(peerFromMTP(update.vpeer))) {
|
|
|
|
if (const auto chat = peer->asChat()) {
|
|
|
|
ApplyChatUpdate(chat, update);
|
|
|
|
} else if (const auto channel = peer->asChannel()) {
|
|
|
|
ApplyChannelUpdate(channel, update);
|
|
|
|
} else {
|
|
|
|
LOG(("API Error: "
|
|
|
|
"User received in updateChatDefaultBannedRights."));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-21 12:27:46 +00:00
|
|
|
not_null<LocationThumbnail*> Session::location(const LocationPoint &point) {
|
|
|
|
const auto i = _locations.find(point);
|
|
|
|
return (i != _locations.cend())
|
|
|
|
? i->second.get()
|
|
|
|
: _locations.emplace(
|
|
|
|
point,
|
|
|
|
std::make_unique<LocationThumbnail>(point)).first->second.get();
|
2018-10-11 15:54:57 +00:00
|
|
|
}
|
|
|
|
|
2018-01-21 19:52:44 +00:00
|
|
|
void Session::registerPhotoItem(
|
2018-01-17 16:21:01 +00:00
|
|
|
not_null<const PhotoData*> photo,
|
2018-01-21 19:52:44 +00:00
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
_photoItems[photo].insert(item);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
|
2018-01-21 19:52:44 +00:00
|
|
|
void Session::unregisterPhotoItem(
|
2018-01-17 16:21:01 +00:00
|
|
|
not_null<const PhotoData*> photo,
|
2018-01-21 19:52:44 +00:00
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
const auto i = _photoItems.find(photo);
|
|
|
|
if (i != _photoItems.end()) {
|
2018-01-17 16:21:01 +00:00
|
|
|
auto &items = i->second;
|
2018-01-21 19:52:44 +00:00
|
|
|
if (items.remove(item) && items.empty()) {
|
|
|
|
_photoItems.erase(i);
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerDocumentItem(
|
|
|
|
not_null<const DocumentData*> document,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
_documentItems[document].insert(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterDocumentItem(
|
|
|
|
not_null<const DocumentData*> document,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
const auto i = _documentItems.find(document);
|
|
|
|
if (i != _documentItems.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(item) && items.empty()) {
|
|
|
|
_documentItems.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerWebPageView(
|
|
|
|
not_null<const WebPageData*> page,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
_webpageViews[page].insert(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterWebPageView(
|
|
|
|
not_null<const WebPageData*> page,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto i = _webpageViews.find(page);
|
|
|
|
if (i != _webpageViews.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(view) && items.empty()) {
|
|
|
|
_webpageViews.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerWebPageItem(
|
|
|
|
not_null<const WebPageData*> page,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
_webpageItems[page].insert(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterWebPageItem(
|
|
|
|
not_null<const WebPageData*> page,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
const auto i = _webpageItems.find(page);
|
|
|
|
if (i != _webpageItems.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(item) && items.empty()) {
|
|
|
|
_webpageItems.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerGameView(
|
|
|
|
not_null<const GameData*> game,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
_gameViews[game].insert(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterGameView(
|
|
|
|
not_null<const GameData*> game,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto i = _gameViews.find(game);
|
|
|
|
if (i != _gameViews.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(view) && items.empty()) {
|
|
|
|
_gameViews.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-18 05:43:11 +00:00
|
|
|
void Session::registerPollView(
|
|
|
|
not_null<const PollData*> poll,
|
|
|
|
not_null<ViewElement*> view) {
|
|
|
|
_pollViews[poll].insert(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterPollView(
|
|
|
|
not_null<const PollData*> poll,
|
|
|
|
not_null<ViewElement*> view) {
|
|
|
|
const auto i = _pollViews.find(poll);
|
|
|
|
if (i != _pollViews.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(view) && items.empty()) {
|
|
|
|
_pollViews.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Session::registerContactView(
|
|
|
|
UserId contactId,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
if (!contactId) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
_contactViews[contactId].insert(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterContactView(
|
|
|
|
UserId contactId,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
if (!contactId) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
const auto i = _contactViews.find(contactId);
|
|
|
|
if (i != _contactViews.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(view) && items.empty()) {
|
|
|
|
_contactViews.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerContactItem(
|
|
|
|
UserId contactId,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
if (!contactId) {
|
|
|
|
return;
|
|
|
|
}
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto contact = userLoaded(contactId);
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto canShare = contact ? contact->canShareThisContact() : false;
|
|
|
|
|
|
|
|
_contactItems[contactId].insert(item);
|
|
|
|
|
|
|
|
if (contact && canShare != contact->canShareThisContact()) {
|
|
|
|
Notify::peerUpdatedDelayed(
|
|
|
|
contact,
|
|
|
|
Notify::PeerUpdate::Flag::UserCanShareContact);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const auto i = _views.find(item); i != _views.end()) {
|
|
|
|
for (const auto view : i->second) {
|
|
|
|
if (const auto media = view->media()) {
|
|
|
|
media->updateSharedContactUserId(contactId);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterContactItem(
|
|
|
|
UserId contactId,
|
|
|
|
not_null<HistoryItem*> item) {
|
|
|
|
if (!contactId) {
|
|
|
|
return;
|
|
|
|
}
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto contact = userLoaded(contactId);
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto canShare = contact ? contact->canShareThisContact() : false;
|
|
|
|
|
|
|
|
const auto i = _contactItems.find(contactId);
|
|
|
|
if (i != _contactItems.end()) {
|
|
|
|
auto &items = i->second;
|
|
|
|
if (items.remove(item) && items.empty()) {
|
|
|
|
_contactItems.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (contact && canShare != contact->canShareThisContact()) {
|
|
|
|
Notify::peerUpdatedDelayed(
|
|
|
|
contact,
|
|
|
|
Notify::PeerUpdate::Flag::UserCanShareContact);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerAutoplayAnimation(
|
|
|
|
not_null<::Media::Clip::Reader*> reader,
|
2018-01-17 18:20:55 +00:00
|
|
|
not_null<ViewElement*> view) {
|
2018-01-17 16:21:01 +00:00
|
|
|
_autoplayAnimations.emplace(reader, view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterAutoplayAnimation(
|
|
|
|
not_null<::Media::Clip::Reader*> reader) {
|
|
|
|
_autoplayAnimations.remove(reader);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::stopAutoplayAnimations() {
|
|
|
|
for (const auto [reader, view] : base::take(_autoplayAnimations)) {
|
|
|
|
if (const auto media = view->media()) {
|
2018-01-21 14:49:42 +00:00
|
|
|
media->stopAnimation();
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
HistoryItem *Session::findWebPageItem(not_null<WebPageData*> page) const {
|
|
|
|
const auto i = _webpageItems.find(page);
|
|
|
|
if (i != _webpageItems.end()) {
|
|
|
|
for (const auto item : i->second) {
|
|
|
|
if (IsServerMsgId(item->id)) {
|
|
|
|
return item;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Session::findContactPhone(not_null<UserData*> contact) const {
|
|
|
|
const auto result = contact->phone();
|
|
|
|
return result.isEmpty()
|
|
|
|
? findContactPhone(contact->bareId())
|
|
|
|
: App::formatPhone(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Session::findContactPhone(UserId contactId) const {
|
|
|
|
const auto i = _contactItems.find(contactId);
|
|
|
|
if (i != _contactItems.end()) {
|
|
|
|
if (const auto media = (*begin(i->second))->media()) {
|
|
|
|
if (const auto contact = media->sharedContact()) {
|
|
|
|
return contact->phoneNumber;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2018-12-18 05:43:11 +00:00
|
|
|
bool Session::hasPendingWebPageGamePollNotification() const {
|
|
|
|
return !_webpagesUpdated.empty()
|
|
|
|
|| !_gamesUpdated.empty()
|
|
|
|
|| !_pollsUpdated.empty();
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Session::notifyWebPageUpdateDelayed(not_null<WebPageData*> page) {
|
2018-12-18 05:43:11 +00:00
|
|
|
const auto invoke = !hasPendingWebPageGamePollNotification();
|
2018-01-17 16:21:01 +00:00
|
|
|
_webpagesUpdated.insert(page);
|
|
|
|
if (invoke) {
|
2018-12-18 05:43:11 +00:00
|
|
|
crl::on_main(_session, [=] { sendWebPageGamePollNotifications(); });
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::notifyGameUpdateDelayed(not_null<GameData*> game) {
|
2018-12-18 05:43:11 +00:00
|
|
|
const auto invoke = !hasPendingWebPageGamePollNotification();
|
2018-01-17 16:21:01 +00:00
|
|
|
_gamesUpdated.insert(game);
|
|
|
|
if (invoke) {
|
2018-12-18 05:43:11 +00:00
|
|
|
crl::on_main(_session, [=] { sendWebPageGamePollNotifications(); });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::notifyPollUpdateDelayed(not_null<PollData*> poll) {
|
|
|
|
const auto invoke = !hasPendingWebPageGamePollNotification();
|
|
|
|
_pollsUpdated.insert(poll);
|
|
|
|
if (invoke) {
|
|
|
|
crl::on_main(_session, [=] { sendWebPageGamePollNotifications(); });
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-18 05:43:11 +00:00
|
|
|
void Session::sendWebPageGamePollNotifications() {
|
2018-01-17 16:21:01 +00:00
|
|
|
for (const auto page : base::take(_webpagesUpdated)) {
|
|
|
|
const auto i = _webpageViews.find(page);
|
|
|
|
if (i != _webpageViews.end()) {
|
|
|
|
for (const auto view : i->second) {
|
|
|
|
requestViewResize(view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const auto game : base::take(_gamesUpdated)) {
|
|
|
|
if (const auto i = _gameViews.find(game); i != _gameViews.end()) {
|
|
|
|
for (const auto view : i->second) {
|
2018-12-18 05:43:11 +00:00
|
|
|
requestViewResize(view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (const auto poll : base::take(_pollsUpdated)) {
|
|
|
|
if (const auto i = _pollViews.find(poll); i != _pollViews.end()) {
|
|
|
|
for (const auto view : i->second) {
|
2018-01-17 16:21:01 +00:00
|
|
|
requestViewResize(view);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::registerItemView(not_null<ViewElement*> view) {
|
|
|
|
_views[view->data()].push_back(view);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::unregisterItemView(not_null<ViewElement*> view) {
|
|
|
|
const auto i = _views.find(view->data());
|
|
|
|
if (i != end(_views)) {
|
|
|
|
auto &list = i->second;
|
|
|
|
list.erase(ranges::remove(list, view), end(list));
|
|
|
|
if (list.empty()) {
|
|
|
|
_views.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (App::hoveredItem() == view) {
|
|
|
|
App::hoveredItem(nullptr);
|
|
|
|
}
|
|
|
|
if (App::pressedItem() == view) {
|
|
|
|
App::pressedItem(nullptr);
|
|
|
|
}
|
|
|
|
if (App::hoveredLinkItem() == view) {
|
|
|
|
App::hoveredLinkItem(nullptr);
|
|
|
|
}
|
|
|
|
if (App::pressedLinkItem() == view) {
|
|
|
|
App::pressedLinkItem(nullptr);
|
|
|
|
}
|
|
|
|
if (App::mousedItem() == view) {
|
|
|
|
App::mousedItem(nullptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-15 11:54:03 +00:00
|
|
|
not_null<Folder*> Session::folder(FolderId id) {
|
|
|
|
if (const auto result = folderLoaded(id)) {
|
2018-01-04 10:22:53 +00:00
|
|
|
return result;
|
|
|
|
}
|
2019-04-15 11:54:03 +00:00
|
|
|
const auto [it, ok] = _folders.emplace(
|
2018-01-04 10:22:53 +00:00
|
|
|
id,
|
2019-04-15 11:54:03 +00:00
|
|
|
std::make_unique<Folder>(this, id));
|
2018-01-04 10:22:53 +00:00
|
|
|
return it->second.get();
|
|
|
|
}
|
|
|
|
|
2019-04-19 08:47:49 +00:00
|
|
|
Folder *Session::folderLoaded(FolderId id) const {
|
2019-04-15 11:54:03 +00:00
|
|
|
const auto it = _folders.find(id);
|
|
|
|
return (it == end(_folders)) ? nullptr : it->second.get();
|
|
|
|
}
|
2019-04-16 08:50:59 +00:00
|
|
|
|
|
|
|
not_null<Folder*> Session::processFolder(const MTPFolder &data) {
|
|
|
|
return data.match([&](const MTPDfolder &data) {
|
|
|
|
return processFolder(data);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<Folder*> Session::processFolder(const MTPDfolder &data) {
|
|
|
|
const auto result = folder(data.vid.v);
|
|
|
|
//if (data.has_photo()) {
|
|
|
|
// data.vphoto;
|
|
|
|
//}
|
|
|
|
//data.vtitle;
|
|
|
|
return result;
|
|
|
|
}
|
2019-04-15 11:54:03 +00:00
|
|
|
// // #feed
|
|
|
|
//void Session::setDefaultFeedId(FeedId id) {
|
|
|
|
// _defaultFeedId = id;
|
|
|
|
//}
|
|
|
|
//
|
|
|
|
//FeedId Session::defaultFeedId() const {
|
|
|
|
// return _defaultFeedId.current();
|
|
|
|
//}
|
|
|
|
//
|
|
|
|
//rpl::producer<FeedId> Session::defaultFeedIdValue() const {
|
|
|
|
// return _defaultFeedId.value();
|
|
|
|
//}
|
2018-02-08 09:20:14 +00:00
|
|
|
|
2019-04-22 14:22:39 +00:00
|
|
|
not_null<Dialogs::MainList*> Session::chatsList(Data::Folder *folder) {
|
|
|
|
return folder ? folder->chatsList().get() : &_chatsList;
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<const Dialogs::MainList*> Session::chatsList(
|
|
|
|
Data::Folder *folder) const {
|
|
|
|
return folder ? folder->chatsList() : &_chatsList;
|
2019-04-16 14:05:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
not_null<Dialogs::IndexedList*> Session::contactsList() {
|
|
|
|
return &_contactsList;
|
|
|
|
}
|
|
|
|
|
|
|
|
not_null<Dialogs::IndexedList*> Session::contactsNoChatsList() {
|
|
|
|
return &_contactsNoChatsList;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Session::refreshChatListEntry(Dialogs::Key key)
|
|
|
|
-> RefreshChatListEntryResult {
|
|
|
|
using namespace Dialogs;
|
|
|
|
|
|
|
|
const auto entry = key.entry();
|
|
|
|
auto result = RefreshChatListEntryResult();
|
2019-04-22 14:22:39 +00:00
|
|
|
result.changed = !entry->inChatList();
|
2019-04-16 14:05:56 +00:00
|
|
|
if (result.changed) {
|
2019-04-17 13:22:37 +00:00
|
|
|
const auto mainRow = entry->addToChatList(Mode::All);
|
2019-04-16 14:05:56 +00:00
|
|
|
_contactsNoChatsList.del(key, mainRow);
|
|
|
|
} else {
|
2019-04-17 13:22:37 +00:00
|
|
|
result.moved = entry->adjustByPosInChatList(Mode::All);
|
2019-04-16 14:05:56 +00:00
|
|
|
}
|
|
|
|
if (Global::DialogsModeEnabled()) {
|
|
|
|
if (entry->toImportant()) {
|
|
|
|
result.importantChanged = !entry->inChatList(Mode::Important);
|
|
|
|
if (result.importantChanged) {
|
2019-04-17 13:22:37 +00:00
|
|
|
entry->addToChatList(Mode::Important);
|
2019-04-16 14:05:56 +00:00
|
|
|
} else {
|
|
|
|
result.importantMoved = entry->adjustByPosInChatList(
|
2019-04-17 13:22:37 +00:00
|
|
|
Mode::Important);
|
2019-04-16 14:05:56 +00:00
|
|
|
}
|
|
|
|
} else if (entry->inChatList(Mode::Important)) {
|
2019-04-17 13:22:37 +00:00
|
|
|
entry->removeFromChatList(Mode::Important);
|
2019-04-16 14:05:56 +00:00
|
|
|
result.importantChanged = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::removeChatListEntry(Dialogs::Key key) {
|
|
|
|
using namespace Dialogs;
|
|
|
|
|
|
|
|
const auto entry = key.entry();
|
2019-04-17 13:22:37 +00:00
|
|
|
entry->removeFromChatList(Mode::All);
|
2019-04-16 14:05:56 +00:00
|
|
|
if (Global::DialogsModeEnabled()) {
|
2019-04-17 13:22:37 +00:00
|
|
|
entry->removeFromChatList(Mode::Important);
|
2019-04-16 14:05:56 +00:00
|
|
|
}
|
|
|
|
if (_contactsList.contains(key)) {
|
|
|
|
if (!_contactsNoChatsList.contains(key)) {
|
|
|
|
_contactsNoChatsList.addByName(key);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::dialogsRowReplaced(DialogsRowReplacement replacement) {
|
|
|
|
_dialogsRowReplacements.fire(std::move(replacement));
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Session::dialogsRowReplacements() const
|
|
|
|
-> rpl::producer<DialogsRowReplacement> {
|
|
|
|
return _dialogsRowReplacements.events();
|
|
|
|
}
|
|
|
|
|
2018-04-09 17:48:29 +00:00
|
|
|
void Session::requestNotifySettings(not_null<PeerData*> peer) {
|
|
|
|
if (peer->notifySettingsUnknown()) {
|
|
|
|
_session->api().requestNotifySettings(
|
|
|
|
MTP_inputNotifyPeer(peer->input));
|
|
|
|
}
|
|
|
|
if (defaultNotifySettings(peer).settingsUnknown()) {
|
|
|
|
_session->api().requestNotifySettings(peer->isUser()
|
|
|
|
? MTP_inputNotifyUsers()
|
2018-11-06 11:10:20 +00:00
|
|
|
: (peer->isChat() || peer->isMegagroup())
|
|
|
|
? MTP_inputNotifyChats()
|
|
|
|
: MTP_inputNotifyBroadcasts());
|
2018-04-09 17:48:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::applyNotifySetting(
|
|
|
|
const MTPNotifyPeer ¬ifyPeer,
|
|
|
|
const MTPPeerNotifySettings &settings) {
|
|
|
|
switch (notifyPeer.type()) {
|
|
|
|
case mtpc_notifyUsers: {
|
|
|
|
if (_defaultUserNotifySettings.change(settings)) {
|
|
|
|
_defaultUserNotifyUpdates.fire({});
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
enumerateUsers([&](not_null<UserData*> user) {
|
2018-04-09 17:48:29 +00:00
|
|
|
if (!user->notifySettingsUnknown()
|
|
|
|
&& ((!user->notifyMuteUntil()
|
|
|
|
&& _defaultUserNotifySettings.muteUntil())
|
|
|
|
|| (!user->notifySilentPosts()
|
|
|
|
&& _defaultUserNotifySettings.silentPosts()))) {
|
|
|
|
updateNotifySettingsLocal(user);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case mtpc_notifyChats: {
|
|
|
|
if (_defaultChatNotifySettings.change(settings)) {
|
|
|
|
_defaultChatNotifyUpdates.fire({});
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
enumerateGroups([&](not_null<PeerData*> peer) {
|
2018-04-09 17:48:29 +00:00
|
|
|
if (!peer->notifySettingsUnknown()
|
|
|
|
&& ((!peer->notifyMuteUntil()
|
2018-06-06 19:56:35 +00:00
|
|
|
&& _defaultChatNotifySettings.muteUntil())
|
2018-04-09 17:48:29 +00:00
|
|
|
|| (!peer->notifySilentPosts()
|
2018-06-06 19:56:35 +00:00
|
|
|
&& _defaultChatNotifySettings.silentPosts()))) {
|
2018-04-09 17:48:29 +00:00
|
|
|
updateNotifySettingsLocal(peer);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
} break;
|
2018-11-06 11:10:20 +00:00
|
|
|
case mtpc_notifyBroadcasts: {
|
|
|
|
if (_defaultBroadcastNotifySettings.change(settings)) {
|
|
|
|
_defaultBroadcastNotifyUpdates.fire({});
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
enumerateChannels([&](not_null<ChannelData*> channel) {
|
2018-11-06 11:10:20 +00:00
|
|
|
if (!channel->notifySettingsUnknown()
|
|
|
|
&& ((!channel->notifyMuteUntil()
|
|
|
|
&& _defaultBroadcastNotifySettings.muteUntil())
|
|
|
|
|| (!channel->notifySilentPosts()
|
|
|
|
&& _defaultBroadcastNotifySettings.silentPosts()))) {
|
|
|
|
updateNotifySettingsLocal(channel);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
} break;
|
2018-04-09 17:48:29 +00:00
|
|
|
case mtpc_notifyPeer: {
|
|
|
|
const auto &data = notifyPeer.c_notifyPeer();
|
2019-01-03 12:36:01 +00:00
|
|
|
if (const auto peer = peerLoaded(peerFromMTP(data.vpeer))) {
|
2018-04-09 17:48:29 +00:00
|
|
|
if (peer->notifyChange(settings)) {
|
|
|
|
updateNotifySettingsLocal(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Session::updateNotifySettings(
|
|
|
|
not_null<PeerData*> peer,
|
2018-09-21 16:28:46 +00:00
|
|
|
std::optional<int> muteForSeconds,
|
|
|
|
std::optional<bool> silentPosts) {
|
2018-04-09 17:48:29 +00:00
|
|
|
if (peer->notifyChange(muteForSeconds, silentPosts)) {
|
|
|
|
updateNotifySettingsLocal(peer);
|
|
|
|
_session->api().updateNotifySettingsDelayed(peer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::notifyIsMuted(
|
|
|
|
not_null<const PeerData*> peer,
|
2019-02-19 06:57:53 +00:00
|
|
|
crl::time *changesIn) const {
|
2018-04-09 17:48:29 +00:00
|
|
|
const auto resultFromUntil = [&](TimeId until) {
|
|
|
|
const auto now = unixtime();
|
|
|
|
const auto result = (until > now) ? (until - now) : 0;
|
|
|
|
if (changesIn) {
|
|
|
|
*changesIn = (result > 0)
|
2019-02-19 06:57:53 +00:00
|
|
|
? std::min(result * crl::time(1000), kMaxNotifyCheckDelay)
|
2018-04-09 17:48:29 +00:00
|
|
|
: kMaxNotifyCheckDelay;
|
|
|
|
}
|
|
|
|
return (result > 0);
|
|
|
|
};
|
|
|
|
if (const auto until = peer->notifyMuteUntil()) {
|
|
|
|
return resultFromUntil(*until);
|
|
|
|
}
|
|
|
|
const auto &settings = defaultNotifySettings(peer);
|
|
|
|
if (const auto until = settings.muteUntil()) {
|
|
|
|
return resultFromUntil(*until);
|
|
|
|
}
|
2018-06-07 19:28:09 +00:00
|
|
|
return true;
|
2018-04-09 17:48:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::notifySilentPosts(not_null<const PeerData*> peer) const {
|
|
|
|
if (const auto silent = peer->notifySilentPosts()) {
|
|
|
|
return *silent;
|
|
|
|
}
|
|
|
|
const auto &settings = defaultNotifySettings(peer);
|
|
|
|
if (const auto silent = settings.silentPosts()) {
|
|
|
|
return *silent;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::notifyMuteUnknown(not_null<const PeerData*> peer) const {
|
|
|
|
if (peer->notifySettingsUnknown()) {
|
|
|
|
return true;
|
|
|
|
} else if (const auto nonDefault = peer->notifyMuteUntil()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return defaultNotifySettings(peer).settingsUnknown();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::notifySilentPostsUnknown(
|
|
|
|
not_null<const PeerData*> peer) const {
|
|
|
|
if (peer->notifySettingsUnknown()) {
|
|
|
|
return true;
|
|
|
|
} else if (const auto nonDefault = peer->notifySilentPosts()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return defaultNotifySettings(peer).settingsUnknown();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Session::notifySettingsUnknown(not_null<const PeerData*> peer) const {
|
|
|
|
return notifyMuteUnknown(peer) || notifySilentPostsUnknown(peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::defaultUserNotifyUpdates() const {
|
|
|
|
return _defaultUserNotifyUpdates.events();
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::defaultChatNotifyUpdates() const {
|
|
|
|
return _defaultChatNotifyUpdates.events();
|
|
|
|
}
|
|
|
|
|
2018-11-06 11:10:20 +00:00
|
|
|
rpl::producer<> Session::defaultBroadcastNotifyUpdates() const {
|
|
|
|
return _defaultBroadcastNotifyUpdates.events();
|
|
|
|
}
|
|
|
|
|
2018-04-09 17:48:29 +00:00
|
|
|
rpl::producer<> Session::defaultNotifyUpdates(
|
|
|
|
not_null<const PeerData*> peer) const {
|
|
|
|
return peer->isUser()
|
|
|
|
? defaultUserNotifyUpdates()
|
2018-11-06 11:10:20 +00:00
|
|
|
: (peer->isChat() || peer->isMegagroup())
|
|
|
|
? defaultChatNotifyUpdates()
|
|
|
|
: defaultBroadcastNotifyUpdates();
|
2018-04-09 17:48:29 +00:00
|
|
|
}
|
|
|
|
|
2018-09-27 20:31:48 +00:00
|
|
|
void Session::serviceNotification(
|
|
|
|
const TextWithEntities &message,
|
|
|
|
const MTPMessageMedia &media) {
|
|
|
|
const auto date = unixtime();
|
2019-03-12 10:36:33 +00:00
|
|
|
if (!peerLoaded(PeerData::kServiceNotificationsId)) {
|
2019-01-18 12:27:37 +00:00
|
|
|
processUser(MTP_user(
|
2018-09-27 20:31:48 +00:00
|
|
|
MTP_flags(
|
|
|
|
MTPDuser::Flag::f_first_name
|
|
|
|
| MTPDuser::Flag::f_phone
|
|
|
|
| MTPDuser::Flag::f_status
|
|
|
|
| MTPDuser::Flag::f_verified),
|
2019-03-12 10:36:33 +00:00
|
|
|
MTP_int(peerToUser(PeerData::kServiceNotificationsId)),
|
2018-09-27 20:31:48 +00:00
|
|
|
MTPlong(),
|
|
|
|
MTP_string("Telegram"),
|
|
|
|
MTPstring(),
|
|
|
|
MTPstring(),
|
|
|
|
MTP_string("42777"),
|
|
|
|
MTP_userProfilePhotoEmpty(),
|
|
|
|
MTP_userStatusRecently(),
|
|
|
|
MTPint(),
|
|
|
|
MTPstring(),
|
|
|
|
MTPstring(),
|
2019-01-03 12:36:01 +00:00
|
|
|
MTPstring()));
|
2018-09-27 20:31:48 +00:00
|
|
|
}
|
2019-03-12 10:36:33 +00:00
|
|
|
const auto history = this->history(PeerData::kServiceNotificationsId);
|
2019-04-22 14:22:39 +00:00
|
|
|
if (!history->folderKnown()) {
|
2018-09-27 20:31:48 +00:00
|
|
|
_session->api().requestDialogEntry(history, [=] {
|
|
|
|
insertCheckedServiceNotification(message, media, date);
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
insertCheckedServiceNotification(message, media, date);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-20 10:03:44 +00:00
|
|
|
void Session::checkNewAuthorization() {
|
|
|
|
_newAuthorizationChecks.fire({});
|
|
|
|
}
|
|
|
|
|
|
|
|
rpl::producer<> Session::newAuthorizationChecks() const {
|
|
|
|
return _newAuthorizationChecks.events();
|
|
|
|
}
|
|
|
|
|
2018-09-27 20:31:48 +00:00
|
|
|
void Session::insertCheckedServiceNotification(
|
|
|
|
const TextWithEntities &message,
|
|
|
|
const MTPMessageMedia &media,
|
|
|
|
TimeId date) {
|
2019-03-12 10:36:33 +00:00
|
|
|
const auto history = this->history(PeerData::kServiceNotificationsId);
|
2018-09-27 20:31:48 +00:00
|
|
|
const auto flags = MTPDmessage::Flag::f_entities
|
|
|
|
| MTPDmessage::Flag::f_from_id
|
2019-02-11 12:50:35 +00:00
|
|
|
| MTPDmessage_ClientFlag::f_clientside_unread
|
|
|
|
| MTPDmessage::Flag::f_media;
|
2018-09-27 20:31:48 +00:00
|
|
|
auto sending = TextWithEntities(), left = message;
|
|
|
|
while (TextUtilities::CutPart(sending, left, MaxMessageSize)) {
|
2019-01-03 12:36:01 +00:00
|
|
|
addNewMessage(
|
2018-09-27 20:31:48 +00:00
|
|
|
MTP_message(
|
|
|
|
MTP_flags(flags),
|
|
|
|
MTP_int(clientMsgId()),
|
2019-03-12 10:36:33 +00:00
|
|
|
MTP_int(peerToUser(PeerData::kServiceNotificationsId)),
|
2018-09-27 20:31:48 +00:00
|
|
|
MTP_peerUser(MTP_int(_session->userId())),
|
2019-03-15 15:15:56 +00:00
|
|
|
MTPMessageFwdHeader(),
|
2018-09-27 20:31:48 +00:00
|
|
|
MTPint(),
|
|
|
|
MTPint(),
|
|
|
|
MTP_int(date),
|
|
|
|
MTP_string(sending.text),
|
|
|
|
media,
|
2019-03-15 15:15:56 +00:00
|
|
|
MTPReplyMarkup(),
|
2018-09-27 20:31:48 +00:00
|
|
|
TextUtilities::EntitiesToMTP(sending.entities),
|
|
|
|
MTPint(),
|
|
|
|
MTPint(),
|
|
|
|
MTPstring(),
|
|
|
|
MTPlong()),
|
2019-04-25 12:45:15 +00:00
|
|
|
NewMessageType::Unread);
|
2018-09-27 20:31:48 +00:00
|
|
|
}
|
|
|
|
sendHistoryChangeNotifications();
|
|
|
|
}
|
|
|
|
|
2018-01-11 15:51:59 +00:00
|
|
|
void Session::setMimeForwardIds(MessageIdsList &&list) {
|
|
|
|
_mimeForwardIds = std::move(list);
|
|
|
|
}
|
|
|
|
|
|
|
|
MessageIdsList Session::takeMimeForwardIds() {
|
|
|
|
return std::move(_mimeForwardIds);
|
|
|
|
}
|
|
|
|
|
2018-05-11 14:03:53 +00:00
|
|
|
void Session::setProxyPromoted(PeerData *promoted) {
|
|
|
|
if (_proxyPromoted != promoted) {
|
2019-01-03 12:36:01 +00:00
|
|
|
if (const auto history = historyLoaded(_proxyPromoted)) {
|
2018-05-11 14:03:53 +00:00
|
|
|
history->cacheProxyPromoted(false);
|
|
|
|
}
|
2018-05-15 16:38:27 +00:00
|
|
|
const auto old = std::exchange(_proxyPromoted, promoted);
|
2018-05-11 14:03:53 +00:00
|
|
|
if (_proxyPromoted) {
|
2019-01-03 12:36:01 +00:00
|
|
|
const auto history = this->history(_proxyPromoted);
|
2018-05-11 14:03:53 +00:00
|
|
|
history->cacheProxyPromoted(true);
|
2019-01-15 11:57:45 +00:00
|
|
|
history->requestChatListMessage();
|
2018-05-15 16:38:27 +00:00
|
|
|
Notify::peerUpdatedDelayed(
|
|
|
|
_proxyPromoted,
|
|
|
|
Notify::PeerUpdate::Flag::ChannelPromotedChanged);
|
|
|
|
}
|
|
|
|
if (old) {
|
|
|
|
Notify::peerUpdatedDelayed(
|
|
|
|
old,
|
|
|
|
Notify::PeerUpdate::Flag::ChannelPromotedChanged);
|
2018-05-11 14:03:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PeerData *Session::proxyPromoted() const {
|
|
|
|
return _proxyPromoted;
|
|
|
|
}
|
|
|
|
|
2019-01-16 12:25:29 +00:00
|
|
|
bool Session::updateWallpapers(const MTPaccount_WallPapers &data) {
|
|
|
|
return data.match([&](const MTPDaccount_wallPapers &data) {
|
|
|
|
setWallpapers(data.vwallpapers.v, data.vhash.v);
|
|
|
|
return true;
|
|
|
|
}, [&](const MTPDaccount_wallPapersNotModified &) {
|
|
|
|
return false;
|
|
|
|
});
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-01-16 12:25:29 +00:00
|
|
|
void Session::setWallpapers(const QVector<MTPWallPaper> &data, int32 hash) {
|
|
|
|
_wallpapersHash = hash;
|
2019-01-03 12:36:01 +00:00
|
|
|
|
|
|
|
_wallpapers.clear();
|
2019-02-04 18:37:40 +00:00
|
|
|
_wallpapers.reserve(data.size() + 2);
|
2019-01-03 12:36:01 +00:00
|
|
|
|
2019-02-04 18:37:40 +00:00
|
|
|
_wallpapers.push_back(Data::Legacy1DefaultWallPaper());
|
2019-02-08 13:43:31 +00:00
|
|
|
_wallpapers.back().setLocalImageAsThumbnail(std::make_shared<Image>(
|
|
|
|
std::make_unique<Images::LocalFileSource>(
|
|
|
|
qsl(":/gui/art/bg_initial.jpg"),
|
|
|
|
QByteArray(),
|
|
|
|
"JPG")));
|
2019-01-03 12:36:01 +00:00
|
|
|
for (const auto &paper : data) {
|
|
|
|
paper.match([&](const MTPDwallPaper &paper) {
|
2019-02-05 09:32:54 +00:00
|
|
|
if (const auto parsed = Data::WallPaper::Create(paper)) {
|
2019-01-28 13:59:49 +00:00
|
|
|
_wallpapers.push_back(*parsed);
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2019-02-04 18:37:40 +00:00
|
|
|
const auto defaultFound = ranges::find_if(
|
|
|
|
_wallpapers,
|
|
|
|
Data::IsDefaultWallPaper);
|
|
|
|
if (defaultFound == end(_wallpapers)) {
|
|
|
|
_wallpapers.push_back(Data::DefaultWallPaper());
|
2019-02-08 13:43:31 +00:00
|
|
|
_wallpapers.back().setLocalImageAsThumbnail(std::make_shared<Image>(
|
|
|
|
std::make_unique<Images::LocalFileSource>(
|
|
|
|
qsl(":/gui/arg/bg.jpg"),
|
|
|
|
QByteArray(),
|
|
|
|
"JPG")));
|
2019-02-04 18:37:40 +00:00
|
|
|
}
|
2019-01-03 12:36:01 +00:00
|
|
|
}
|
|
|
|
|
2019-02-09 13:36:07 +00:00
|
|
|
void Session::removeWallpaper(const WallPaper &paper) {
|
|
|
|
const auto i = ranges::find(_wallpapers, paper.id(), &WallPaper::id);
|
|
|
|
if (i != end(_wallpapers)) {
|
|
|
|
_wallpapers.erase(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-16 12:25:29 +00:00
|
|
|
const std::vector<WallPaper> &Session::wallpapers() const {
|
|
|
|
return _wallpapers;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32 Session::wallpapersHash() const {
|
|
|
|
return _wallpapersHash;
|
|
|
|
}
|
|
|
|
|
2019-01-03 12:36:01 +00:00
|
|
|
void Session::clearLocalStorage() {
|
|
|
|
clear();
|
|
|
|
|
|
|
|
_cache->close();
|
|
|
|
_cache->clear();
|
|
|
|
}
|
|
|
|
|
2018-01-04 10:22:53 +00:00
|
|
|
} // namespace Data
|