tdesktop/Telegram/SourceFiles/data/data_user_photos.cpp

236 lines
5.5 KiB
C++
Raw Normal View History

/*
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_user_photos.h"
2019-07-24 11:45:24 +00:00
#include "main/main_session.h"
#include "apiwrap.h"
2019-01-18 12:27:37 +00:00
#include "data/data_session.h"
2020-06-08 09:06:50 +00:00
#include "data/data_user.h"
#include "storage/storage_facade.h"
#include "storage/storage_user_photos.h"
class UserPhotosSliceBuilder {
public:
using Key = UserPhotosSlice::Key;
UserPhotosSliceBuilder(Key key, int limitBefore, int limitAfter);
bool applyUpdate(const Storage::UserPhotosResult &update);
bool applyUpdate(const Storage::UserPhotosSliceUpdate &update);
void checkInsufficientPhotos();
2017-09-27 12:04:19 +00:00
auto insufficientPhotosAround() const {
return _insufficientPhotosAround.events();
}
UserPhotosSlice snapshot() const;
private:
void mergeSliceData(
2018-09-21 16:28:46 +00:00
std::optional<int> count,
const std::deque<PhotoId> &photoIds,
2018-09-21 16:28:46 +00:00
std::optional<int> skippedBefore,
int skippedAfter);
void sliceToLimits();
Key _key;
std::deque<PhotoId> _ids;
2018-09-21 16:28:46 +00:00
std::optional<int> _fullCount;
std::optional<int> _skippedBefore;
int _skippedAfter = 0;
int _limitBefore = 0;
int _limitAfter = 0;
rpl::event_stream<PhotoId> _insufficientPhotosAround;
};
UserPhotosSlice::UserPhotosSlice(Key key)
: UserPhotosSlice(
2017-09-06 14:50:11 +00:00
key,
{},
2018-09-21 16:28:46 +00:00
std::nullopt,
std::nullopt,
std::nullopt) {
}
UserPhotosSlice::UserPhotosSlice(
Key key,
2017-11-23 09:58:12 +00:00
std::deque<PhotoId> &&ids,
2018-09-21 16:28:46 +00:00
std::optional<int> fullCount,
std::optional<int> skippedBefore,
std::optional<int> skippedAfter)
: AbstractSparseIds<std::deque<PhotoId>>(
ids,
fullCount,
skippedBefore,
skippedAfter)
, _key(key) {
2017-11-23 09:58:12 +00:00
}
std::optional<int> UserPhotosSlice::distance(
const Key &a,
const Key &b) const {
if (a.userId != _key.userId
|| b.userId != _key.userId) {
2018-09-21 16:28:46 +00:00
return std::nullopt;
}
if (const auto i = indexOf(a.photoId)) {
if (const auto j = indexOf(b.photoId)) {
return *j - *i;
}
}
2018-09-21 16:28:46 +00:00
return std::nullopt;
}
2017-09-06 14:50:11 +00:00
UserPhotosSliceBuilder::UserPhotosSliceBuilder(
Key key,
int limitBefore,
int limitAfter)
2017-11-23 09:58:12 +00:00
: _key(key)
, _limitBefore(limitBefore)
, _limitAfter(limitAfter) {
}
2017-09-06 14:50:11 +00:00
bool UserPhotosSliceBuilder::applyUpdate(const Storage::UserPhotosResult &update) {
mergeSliceData(
update.count,
update.photoIds,
update.skippedBefore,
update.skippedAfter);
return true;
}
2017-09-06 14:50:11 +00:00
bool UserPhotosSliceBuilder::applyUpdate(const Storage::UserPhotosSliceUpdate &update) {
if (update.userId != _key.userId) {
return false;
}
auto idsCount = update.photoIds ? int(update.photoIds->size()) : 0;
mergeSliceData(
update.count,
update.photoIds ? *update.photoIds : std::deque<PhotoId> {},
update.count | func::add(-idsCount),
0);
return true;
}
2017-09-06 14:50:11 +00:00
void UserPhotosSliceBuilder::checkInsufficientPhotos() {
sliceToLimits();
}
2017-09-06 14:50:11 +00:00
void UserPhotosSliceBuilder::mergeSliceData(
2018-09-21 16:28:46 +00:00
std::optional<int> count,
const std::deque<PhotoId> &photoIds,
2018-09-21 16:28:46 +00:00
std::optional<int> skippedBefore,
int skippedAfter) {
if (photoIds.empty()) {
2017-09-06 14:50:11 +00:00
if (_fullCount != count) {
_fullCount = count;
if (_fullCount && *_fullCount <= _ids.size()) {
_fullCount = _ids.size();
_skippedBefore = _skippedAfter = 0;
}
}
2017-09-06 14:50:11 +00:00
} else {
if (count) {
_fullCount = count;
}
_skippedAfter = skippedAfter;
_ids = photoIds;
2017-09-06 14:50:11 +00:00
if (_fullCount) {
_skippedBefore = *_fullCount
- _skippedAfter
- int(_ids.size());
}
}
sliceToLimits();
}
2017-09-06 14:50:11 +00:00
void UserPhotosSliceBuilder::sliceToLimits() {
auto aroundIt = ranges::find(_ids, _key.photoId);
2017-09-06 14:50:11 +00:00
auto removeFromBegin = (aroundIt - _ids.begin() - _limitBefore);
auto removeFromEnd = (_ids.end() - aroundIt - _limitAfter - 1);
if (removeFromEnd > 0) {
2017-09-06 14:50:11 +00:00
_ids.erase(_ids.end() - removeFromEnd, _ids.end());
_skippedAfter += removeFromEnd;
}
if (removeFromBegin > 0) {
2017-09-06 14:50:11 +00:00
_ids.erase(_ids.begin(), _ids.begin() + removeFromBegin);
if (_skippedBefore) {
*_skippedBefore += removeFromBegin;
}
2017-09-06 14:50:11 +00:00
} else if (removeFromBegin < 0 && (!_skippedBefore || *_skippedBefore > 0)) {
_insufficientPhotosAround.fire(_ids.empty() ? 0 : _ids.front());
}
}
2017-09-06 14:50:11 +00:00
UserPhotosSlice UserPhotosSliceBuilder::snapshot() const {
2017-11-23 09:58:12 +00:00
return UserPhotosSlice(
_key,
base::duplicate(_ids),
_fullCount,
_skippedBefore,
_skippedAfter);
2017-09-06 14:50:11 +00:00
}
rpl::producer<UserPhotosSlice> UserPhotosViewer(
2020-06-08 09:06:50 +00:00
not_null<Main::Session*> session,
2017-09-06 14:50:11 +00:00
UserPhotosSlice::Key key,
int limitBefore,
int limitAfter) {
2020-06-08 09:06:50 +00:00
return [=](auto consumer) {
2017-09-06 14:50:11 +00:00
auto lifetime = rpl::lifetime();
auto builder = lifetime.make_state<UserPhotosSliceBuilder>(
key,
limitBefore,
limitAfter);
auto applyUpdate = [=](auto &&update) {
2017-09-14 19:27:41 +00:00
if (builder->applyUpdate(std::forward<decltype(update)>(update))) {
2017-09-06 14:50:11 +00:00
consumer.put_next(builder->snapshot());
}
};
2020-06-08 09:06:50 +00:00
auto requestPhotosAround = [user = session->data().user(key.userId)](
2017-09-14 19:27:41 +00:00
PhotoId photoId) {
2020-06-08 09:06:50 +00:00
user->session().api().requestUserPhotos(user, photoId);
2017-09-06 14:50:11 +00:00
};
builder->insufficientPhotosAround()
| rpl::start_with_next(requestPhotosAround, lifetime);
2017-09-06 14:50:11 +00:00
2020-06-08 09:06:50 +00:00
session->storage().userPhotosSliceUpdated()
| rpl::start_with_next(applyUpdate, lifetime);
2017-09-06 14:50:11 +00:00
2020-06-08 09:06:50 +00:00
session->storage().query(Storage::UserPhotosQuery(
2017-09-06 14:50:11 +00:00
key,
limitBefore,
limitAfter
)) | rpl::start_with_next_done(
applyUpdate,
[=] { builder->checkInsufficientPhotos(); },
lifetime);
2017-09-06 14:50:11 +00:00
return lifetime;
};
}
2017-11-23 09:58:12 +00:00
rpl::producer<UserPhotosSlice> UserPhotosReversedViewer(
2020-06-08 09:06:50 +00:00
not_null<Main::Session*> session,
2017-11-23 09:58:12 +00:00
UserPhotosSlice::Key key,
int limitBefore,
int limitAfter) {
return UserPhotosViewer(
2020-06-08 09:06:50 +00:00
session,
key,
limitBefore,
limitAfter
) | rpl::map([](UserPhotosSlice &&slice) {
slice.reverse();
return std::move(slice);
});
}