308 lines
8.4 KiB
C++
308 lines
8.4 KiB
C++
|
/*
|
||
|
This file is part of Telegram Desktop,
|
||
|
the official desktop version of Telegram messaging app, see https://telegram.org
|
||
|
|
||
|
Telegram Desktop is free software: you can redistribute it and/or modify
|
||
|
it under the terms of the GNU General Public License as published by
|
||
|
the Free Software Foundation, either version 3 of the License, or
|
||
|
(at your option) any later version.
|
||
|
|
||
|
It is distributed in the hope that it will be useful,
|
||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
GNU General Public License for more details.
|
||
|
|
||
|
In addition, as a special exception, the copyright holders give permission
|
||
|
to link the code of portions of this program with the OpenSSL library.
|
||
|
|
||
|
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
|
||
|
Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
|
||
|
*/
|
||
|
#include "history/history_search_controller.h"
|
||
|
|
||
|
#include "auth_session.h"
|
||
|
|
||
|
namespace Api {
|
||
|
namespace {
|
||
|
|
||
|
constexpr auto kSharedMediaLimit = 100;
|
||
|
constexpr auto kDefaultSearchTimeoutMs = TimeMs(200);
|
||
|
|
||
|
} // namespace
|
||
|
|
||
|
MTPmessages_Search PrepareSearchRequest(
|
||
|
not_null<PeerData*> peer,
|
||
|
Storage::SharedMediaType type,
|
||
|
const QString &query,
|
||
|
MsgId messageId,
|
||
|
SparseIdsLoadDirection direction) {
|
||
|
auto filter = [&] {
|
||
|
using Type = Storage::SharedMediaType;
|
||
|
switch (type) {
|
||
|
case Type::Photo:
|
||
|
return MTP_inputMessagesFilterPhotos();
|
||
|
case Type::Video:
|
||
|
return MTP_inputMessagesFilterVideo();
|
||
|
case Type::MusicFile:
|
||
|
return MTP_inputMessagesFilterMusic();
|
||
|
case Type::File:
|
||
|
return MTP_inputMessagesFilterDocument();
|
||
|
case Type::VoiceFile:
|
||
|
return MTP_inputMessagesFilterVoice();
|
||
|
case Type::RoundVoiceFile:
|
||
|
return MTP_inputMessagesFilterRoundVoice();
|
||
|
case Type::RoundFile:
|
||
|
return MTP_inputMessagesFilterRoundVideo();
|
||
|
case Type::GIF:
|
||
|
return MTP_inputMessagesFilterGif();
|
||
|
case Type::Link:
|
||
|
return MTP_inputMessagesFilterUrl();
|
||
|
case Type::ChatPhoto:
|
||
|
return MTP_inputMessagesFilterChatPhotos();
|
||
|
}
|
||
|
return MTP_inputMessagesFilterEmpty();
|
||
|
}();
|
||
|
|
||
|
auto minId = 0;
|
||
|
auto maxId = 0;
|
||
|
auto limit = messageId ? kSharedMediaLimit : 0;
|
||
|
auto offsetId = [&] {
|
||
|
switch (direction) {
|
||
|
case SparseIdsLoadDirection::Before:
|
||
|
case SparseIdsLoadDirection::Around: return messageId;
|
||
|
case SparseIdsLoadDirection::After: return messageId + 1;
|
||
|
}
|
||
|
Unexpected("Direction in PrepareSearchRequest");
|
||
|
}();
|
||
|
auto addOffset = [&] {
|
||
|
switch (direction) {
|
||
|
case SparseIdsLoadDirection::Before: return 0;
|
||
|
case SparseIdsLoadDirection::Around: return -limit / 2;
|
||
|
case SparseIdsLoadDirection::After: return -limit;
|
||
|
}
|
||
|
Unexpected("Direction in PrepareSearchRequest");
|
||
|
}();
|
||
|
|
||
|
return MTPmessages_Search(
|
||
|
MTP_flags(0),
|
||
|
peer->input,
|
||
|
MTP_string(query),
|
||
|
MTP_inputUserEmpty(),
|
||
|
filter,
|
||
|
MTP_int(0),
|
||
|
MTP_int(0),
|
||
|
MTP_int(offsetId),
|
||
|
MTP_int(addOffset),
|
||
|
MTP_int(limit),
|
||
|
MTP_int(maxId),
|
||
|
MTP_int(minId));
|
||
|
}
|
||
|
|
||
|
SearchResult ParseSearchResult(
|
||
|
not_null<PeerData*> peer,
|
||
|
Storage::SharedMediaType type,
|
||
|
MsgId messageId,
|
||
|
SparseIdsLoadDirection direction,
|
||
|
const MTPmessages_Messages &data) {
|
||
|
auto result = SearchResult();
|
||
|
auto &messages = *[&] {
|
||
|
switch (data.type()) {
|
||
|
case mtpc_messages_messages: {
|
||
|
auto &d = data.c_messages_messages();
|
||
|
App::feedUsers(d.vusers);
|
||
|
App::feedChats(d.vchats);
|
||
|
result.fullCount = d.vmessages.v.size();
|
||
|
return &d.vmessages.v;
|
||
|
} break;
|
||
|
|
||
|
case mtpc_messages_messagesSlice: {
|
||
|
auto &d = data.c_messages_messagesSlice();
|
||
|
App::feedUsers(d.vusers);
|
||
|
App::feedChats(d.vchats);
|
||
|
result.fullCount = d.vcount.v;
|
||
|
return &d.vmessages.v;
|
||
|
} break;
|
||
|
|
||
|
case mtpc_messages_channelMessages: {
|
||
|
auto &d = data.c_messages_channelMessages();
|
||
|
if (auto channel = peer->asChannel()) {
|
||
|
channel->ptsReceived(d.vpts.v);
|
||
|
} else {
|
||
|
LOG(("API Error: received messages.channelMessages when no channel was passed! (ParseSearchResult)"));
|
||
|
}
|
||
|
App::feedUsers(d.vusers);
|
||
|
App::feedChats(d.vchats);
|
||
|
result.fullCount = d.vcount.v;
|
||
|
return &d.vmessages.v;
|
||
|
} break;
|
||
|
}
|
||
|
Unexpected("messages.Messages type in ParseSearchResult()");
|
||
|
}();
|
||
|
|
||
|
result.noSkipRange = MsgRange{ messageId, messageId };
|
||
|
auto addType = NewMessageExisting;
|
||
|
result.messageIds.reserve(messages.size());
|
||
|
for (auto &message : messages) {
|
||
|
if (auto item = App::histories().addNewMessage(message, addType)) {
|
||
|
if ((type == Storage::SharedMediaType::kCount)
|
||
|
|| item->sharedMediaTypes().test(type)) {
|
||
|
auto itemId = item->id;
|
||
|
result.messageIds.push_back(itemId);
|
||
|
accumulate_min(result.noSkipRange.from, itemId);
|
||
|
accumulate_max(result.noSkipRange.till, itemId);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (messageId && result.messageIds.empty()) {
|
||
|
result.noSkipRange = [&]() -> MsgRange {
|
||
|
switch (direction) {
|
||
|
case SparseIdsLoadDirection::Before: // All old loaded.
|
||
|
return { 0, result.noSkipRange.till };
|
||
|
case SparseIdsLoadDirection::Around: // All loaded.
|
||
|
return { 0, ServerMaxMsgId };
|
||
|
case SparseIdsLoadDirection::After: // All new loaded.
|
||
|
return { result.noSkipRange.from, ServerMaxMsgId };
|
||
|
}
|
||
|
Unexpected("Direction in ParseSearchResult");
|
||
|
}();
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
SingleSearchController::SingleSearchController(const Query &query)
|
||
|
: _query(query)
|
||
|
, _peerData(App::peer(query.peerId))
|
||
|
, _migratedData(query.migratedPeerId
|
||
|
? base::make_optional(Data(App::peer(query.migratedPeerId)))
|
||
|
: base::none) {
|
||
|
}
|
||
|
|
||
|
rpl::producer<SparseIdsMergedSlice> SingleSearchController::idsSlice(
|
||
|
SparseIdsMergedSlice::UniversalMsgId aroundId,
|
||
|
int limitBefore,
|
||
|
int limitAfter) {
|
||
|
auto createSimpleViewer = [this](
|
||
|
PeerId peerId,
|
||
|
SparseIdsSlice::Key simpleKey,
|
||
|
int limitBefore,
|
||
|
int limitAfter) {
|
||
|
return simpleIdsSlice(
|
||
|
peerId,
|
||
|
simpleKey,
|
||
|
limitBefore,
|
||
|
limitAfter);
|
||
|
};
|
||
|
return SparseIdsMergedSlice::CreateViewer(
|
||
|
SparseIdsMergedSlice::Key(
|
||
|
_query.peerId,
|
||
|
_query.migratedPeerId,
|
||
|
aroundId),
|
||
|
limitBefore,
|
||
|
limitAfter,
|
||
|
std::move(createSimpleViewer));
|
||
|
}
|
||
|
|
||
|
rpl::producer<SparseIdsSlice> SingleSearchController::simpleIdsSlice(
|
||
|
PeerId peerId,
|
||
|
MsgId aroundId,
|
||
|
int limitBefore,
|
||
|
int limitAfter) {
|
||
|
Expects(peerId != 0);
|
||
|
Expects(IsServerMsgId(aroundId) || (aroundId == 0));
|
||
|
Expects((aroundId != 0)
|
||
|
|| (limitBefore == 0 && limitAfter == 0));
|
||
|
Expects((_query.peerId == peerId)
|
||
|
|| (_query.migratedPeerId == peerId));
|
||
|
|
||
|
auto listData = (peerId == _query.peerId)
|
||
|
? &_peerData
|
||
|
: &*_migratedData;
|
||
|
return [=](auto consumer) {
|
||
|
auto lifetime = rpl::lifetime();
|
||
|
auto builder = lifetime.make_state<SparseIdsSliceBuilder>(
|
||
|
aroundId,
|
||
|
limitBefore,
|
||
|
limitAfter);
|
||
|
builder->insufficientAround()
|
||
|
| rpl::start_with_next([=](
|
||
|
const SparseIdsSliceBuilder::AroundData &data) {
|
||
|
requestMore(data, listData);
|
||
|
}, lifetime);
|
||
|
|
||
|
auto pushNextSnapshot = [=] {
|
||
|
consumer.put_next(builder->snapshot());
|
||
|
};
|
||
|
|
||
|
listData->list.sliceUpdated()
|
||
|
| rpl::filter([=](const SliceUpdate &update) {
|
||
|
return builder->applyUpdate(update);
|
||
|
})
|
||
|
| rpl::start_with_next(pushNextSnapshot, lifetime);
|
||
|
|
||
|
Auth().data().itemRemoved()
|
||
|
| rpl::filter([=](not_null<const HistoryItem*> item) {
|
||
|
return (item->history()->peer->id == peerId);
|
||
|
})
|
||
|
| rpl::filter([=](not_null<const HistoryItem*> item) {
|
||
|
return builder->removeOne(item->id);
|
||
|
})
|
||
|
| rpl::start_with_next(pushNextSnapshot, lifetime);
|
||
|
|
||
|
Auth().data().historyCleared()
|
||
|
| rpl::filter([=](not_null<const History*> history) {
|
||
|
return (history->peer->id == peerId);
|
||
|
})
|
||
|
| rpl::filter([=] { return builder->removeAll(); })
|
||
|
| rpl::start_with_next(pushNextSnapshot, lifetime);
|
||
|
|
||
|
builder->checkInsufficient();
|
||
|
|
||
|
return lifetime;
|
||
|
};
|
||
|
}
|
||
|
|
||
|
void SingleSearchController::requestMore(
|
||
|
const SparseIdsSliceBuilder::AroundData &key,
|
||
|
Data *listData) {
|
||
|
if (listData->requests.contains(key)) {
|
||
|
return;
|
||
|
}
|
||
|
auto requestId = request(PrepareSearchRequest(
|
||
|
listData->peer,
|
||
|
_query.type,
|
||
|
_query.query,
|
||
|
key.aroundId,
|
||
|
key.direction)
|
||
|
).done([=](const MTPmessages_Messages &result) {
|
||
|
auto parsed = ParseSearchResult(
|
||
|
listData->peer,
|
||
|
_query.type,
|
||
|
key.aroundId,
|
||
|
key.direction,
|
||
|
result);
|
||
|
listData->list.addSlice(
|
||
|
std::move(parsed.messageIds),
|
||
|
parsed.noSkipRange,
|
||
|
parsed.fullCount);
|
||
|
}).send();
|
||
|
|
||
|
listData->requests.emplace(key, requestId);
|
||
|
}
|
||
|
|
||
|
DelayedSearchController::DelayedSearchController() {
|
||
|
_timer.setCallback([this] { setQueryFast(_nextQuery); });
|
||
|
}
|
||
|
|
||
|
void DelayedSearchController::setQuery(const Query &query) {
|
||
|
setQuery(
|
||
|
query,
|
||
|
query.query.isEmpty() ? 0 : kDefaultSearchTimeoutMs);
|
||
|
}
|
||
|
|
||
|
void DelayedSearchController::setQueryFast(const Query &query) {
|
||
|
_controller.setQuery(query);
|
||
|
_sourceChanges.fire({});
|
||
|
}
|
||
|
|
||
|
} // namespace Api
|