tg_windows5.12.6/Telegram/SourceFiles/api/api_views.cpp

/*
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 "api/api_views.h"

#include "apiwrap.h"
#include "data/data_peer.h"
#include "data/data_peer_id.h"
#include "data/data_session.h"
#include "history/history.h"
#include "history/history_item.h"
#include "main/main_session.h"

namespace Api {
namespace {

// Send channel views each second.
constexpr auto kSendViewsTimeout = crl::time(1000);
constexpr auto kPollExtendedMediaPeriod = 30 * crl::time(1000);
constexpr auto kMaxPollPerRequest = 100;

} // namespace

ViewsManager::ViewsManager(not_null<ApiWrap*> api)
: _session(&api->session())
, _api(&api->instance())
, _incrementTimer([=] { viewsIncrement(); })
, _pollTimer([=] { sendPollRequests(); }) {
}

void ViewsManager::scheduleIncrement(not_null<HistoryItem*> item) {
	auto peer = item->history()->peer;
	auto i = _incremented.find(peer);
	if (i != _incremented.cend()) {
		if (i->second.contains(item->id)) {
			return;
		}
	} else {
		i = _incremented.emplace(peer).first;
	}
	i->second.emplace(item->id);
	auto j = _toIncrement.find(peer);
	if (j == _toIncrement.cend()) {
		j = _toIncrement.emplace(peer).first;
		_incrementTimer.callOnce(kSendViewsTimeout);
	}
	j->second.emplace(item->id);
}

void ViewsManager::removeIncremented(not_null<PeerData*> peer) {
	_incremented.remove(peer);
}

void ViewsManager::pollExtendedMedia(
		not_null<HistoryItem*> item,
		bool force) {
	if (!item->isRegular()) {
		return;
	}
	const auto id = item->id;
	const auto peer = item->history()->peer;
	auto &request = _pollRequests[peer];
	if (request.ids.contains(id) || request.sent.contains(id)) {
		if (!force || request.forced) {
			return;
		}
	}
	request.ids.emplace(id);
	if (force) {
		request.forced = true;
	}
	const auto delay = force ? 1 : kPollExtendedMediaPeriod;
	if (!request.id && (!request.when || force)) {
		request.when = crl::now() + delay;
	}
	if (!_pollTimer.isActive() || force) {
		_pollTimer.callOnce(delay);
	}
}

void ViewsManager::viewsIncrement() {
	for (auto i = _toIncrement.begin(); i != _toIncrement.cend();) {
		if (_incrementRequests.contains(i->first)) {
			++i;
			continue;
		}

		QVector<MTPint> ids;
		ids.reserve(i->second.size());
		for (const auto &msgId : i->second) {
			ids.push_back(MTP_int(msgId));
		}
		const auto requestId = _api.request(MTPmessages_GetMessagesViews(
			i->first->input,
			MTP_vector<MTPint>(ids),
			MTP_bool(true)
		)).done([=](
				const MTPmessages_MessageViews &result,
				mtpRequestId requestId) {
			done(ids, result, requestId);
		}).fail([=](const MTP::Error &error, mtpRequestId requestId) {
			fail(error, requestId);
		}).afterDelay(5).send();

		_incrementRequests.emplace(i->first, requestId);
		i = _toIncrement.erase(i);
	}
}

void ViewsManager::sendPollRequests() {
	const auto now = crl::now();
	auto toRequest = base::flat_map<not_null<PeerData*>, QVector<MTPint>>();
	auto nearest = crl::time();
	for (auto &[peer, request] : _pollRequests) {
		if (request.id) {
			continue;
		} else if (request.when <= now) {
			Assert(request.sent.empty());
			auto &list = toRequest[peer];
			const auto count = int(request.ids.size());
			if (count < kMaxPollPerRequest) {
				request.sent = base::take(request.ids);
			} else {
				const auto from = begin(request.ids);
				const auto end = from + kMaxPollPerRequest;
				request.sent = { from, end };
				request.ids.erase(from, end);
			}
			list.reserve(request.sent.size());
			for (const auto &id : request.sent) {
				list.push_back(MTP_int(id.bare));
			}
			if (!request.ids.empty()) {
				nearest = now;
			}
		} else if (!nearest || nearest > request.when) {
			nearest = request.when;
		}
	}
	sendPollRequests(toRequest);
	if (nearest) {
		_pollTimer.callOnce(std::max(nearest - now, crl::time(1)));
	}
}

void ViewsManager::sendPollRequests(
	const base::flat_map<
		not_null<PeerData*>,
		QVector<MTPint>> &batched) {
	for (auto &[peer, list] : batched) {
		const auto finish = [=, list = list](mtpRequestId id) {
			const auto now = crl::now();
			const auto owner = &_session->data();
			for (auto i = begin(_pollRequests); i != end(_pollRequests);) {
				if (i->second.id == id) {
					const auto peer = i->first->id;
					for (const auto &itemId : i->second.sent) {
						if (const auto item = owner->message(peer, itemId)) {
							owner->requestItemRepaint(item);
						}
					}
					i->second.sent.clear();
					i->second.id = 0;
					if (i->second.ids.empty()) {
						i = _pollRequests.erase(i);
					} else {
						const auto delay = i->second.forced
							? 1
							: kPollExtendedMediaPeriod;
						i->second.when = now + delay;
						if (!_pollTimer.isActive() || i->second.forced) {
							_pollTimer.callOnce(delay);
						}
						++i;
					}
				} else {
					++i;
				}
			}
		};
		const auto requestId = _api.request(MTPmessages_GetExtendedMedia(
			peer->input,
			MTP_vector<MTPint>(list)
		)).done([=](const MTPUpdates &result, mtpRequestId id) {
			_session->api().applyUpdates(result);
			finish(id);
		}).fail([=](const MTP::Error &error, mtpRequestId id) {
			finish(id);
		}).send();

		_pollRequests[peer].id = requestId;
	}
}

void ViewsManager::done(
		QVector<MTPint> ids,
		const MTPmessages_MessageViews &result,
		mtpRequestId requestId) {
	const auto &data = result.c_messages_messageViews();
	auto &owner = _session->data();
	owner.processUsers(data.vusers());
	owner.processChats(data.vchats());
	auto &v = data.vviews().v;
	if (ids.size() == v.size()) {
		for (const auto &[peer, id] : _incrementRequests) {
			if (id != requestId) {
				continue;
			}
			for (auto j = 0, l = int(ids.size()); j < l; ++j) {
				if (const auto item = owner.message(peer->id, ids[j].v)) {
					v[j].match([&](const MTPDmessageViews &data) {
						if (const auto views = data.vviews()) {
							if (item->changeViewsCount(views->v)) {
								_session->data().notifyItemDataChange(item);
							}
						}
						if (const auto forwards = data.vforwards()) {
							item->setForwardsCount(forwards->v);
						}
						if (const auto replies = data.vreplies()) {
							item->setReplies(
								HistoryMessageRepliesData(replies));
						}
					});
				}
			}
			_incrementRequests.erase(peer);
			break;
		}
	}
	if (!_toIncrement.empty() && !_incrementTimer.isActive()) {
		_incrementTimer.callOnce(kSendViewsTimeout);
	}
}

void ViewsManager::fail(const MTP::Error &error, mtpRequestId requestId) {
	for (const auto &[peer, id] : _incrementRequests) {
		if (id == requestId) {
			_incrementRequests.erase(peer);
			break;
		}
	}
	if (!_toIncrement.empty() && !_incrementTimer.isActive()) {
		_incrementTimer.callOnce(kSendViewsTimeout);
	}
}

} // namespace Api