init

Telegram/SourceFiles/data/data_cloud_file.cpp

@@ -0,0 +1,379 @@
+/*
+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_cloud_file.h"
+
+#include "data/data_file_origin.h"
+#include "data/data_session.h"
+#include "storage/cache/storage_cache_database.h"
+#include "storage/file_download.h"
+#include "ui/image/image.h"
+#include "main/main_session.h"
+
+namespace Data {
+
+CloudFile::~CloudFile() {
+	// Destroy loader with still alive CloudFile with already zero '.loader'.
+	// Otherwise in ~FileLoader it tries to clear file.loader and crashes.
+	base::take(loader);
+}
+
+void CloudFile::clear() {
+	location = {};
+	base::take(loader);
+	byteSize = 0;
+	progressivePartSize = 0;
+	flags = {};
+}
+
+CloudImage::CloudImage() = default;
+
+CloudImage::CloudImage(
+		not_null<Main::Session*> session,
+		const ImageWithLocation &data) {
+	update(session, data);
+}
+
+void CloudImage::set(
+		not_null<Main::Session*> session,
+		const ImageWithLocation &data) {
+	const auto &was = _file.location.file().data;
+	const auto &now = data.location.file().data;
+	if (!data.location.valid()) {
+		_file.flags |= CloudFile::Flag::Cancelled;
+		_file.loader = nullptr;
+		_file.location = ImageLocation();
+		_file.byteSize = 0;
+		_file.flags = CloudFile::Flag();
+		_view = std::weak_ptr<QImage>();
+	} else if (was != now
+		&& (!v::is<InMemoryLocation>(was) || v::is<InMemoryLocation>(now))) {
+		_file.location = ImageLocation();
+		_view = std::weak_ptr<QImage>();
+	}
+	UpdateCloudFile(
+		_file,
+		data,
+		session->data().cache(),
+		kImageCacheTag,
+		[=](FileOrigin origin) { load(session, origin); },
+		[=](QImage preloaded, QByteArray) {
+			setToActive(session, std::move(preloaded));
+		});
+}
+
+void CloudImage::update(
+		not_null<Main::Session*> session,
+		const ImageWithLocation &data) {
+	UpdateCloudFile(
+		_file,
+		data,
+		session->data().cache(),
+		kImageCacheTag,
+		[=](FileOrigin origin) { load(session, origin); },
+		[=](QImage preloaded, QByteArray) {
+			setToActive(session, std::move(preloaded));
+		});
+}
+
+bool CloudImage::empty() const {
+	return !_file.location.valid();
+}
+
+bool CloudImage::loading() const {
+	return (_file.loader != nullptr);
+}
+
+bool CloudImage::failed() const {
+	return (_file.flags & CloudFile::Flag::Failed);
+}
+
+bool CloudImage::loadedOnce() const {
+	return (_file.flags & CloudFile::Flag::Loaded);
+}
+
+void CloudImage::load(not_null<Main::Session*> session, FileOrigin origin) {
+	const auto autoLoading = false;
+	const auto finalCheck = [=] {
+		if (const auto active = activeView()) {
+			return active->isNull();
+		} else if (_file.flags & CloudFile::Flag::Loaded) {
+			return false;
+		}
+		return !(_file.flags & CloudFile::Flag::Loaded);
+	};
+	const auto done = [=](QImage result, QByteArray) {
+		setToActive(session, std::move(result));
+	};
+	LoadCloudFile(
+		session,
+		_file,
+		origin,
+		LoadFromCloudOrLocal,
+		autoLoading,
+		kImageCacheTag,
+		finalCheck,
+		done);
+}
+
+const ImageLocation &CloudImage::location() const {
+	return _file.location;
+}
+
+int CloudImage::byteSize() const {
+	return _file.byteSize;
+}
+
+std::shared_ptr<QImage> CloudImage::createView() {
+	if (auto active = activeView()) {
+		return active;
+	}
+	auto view = std::make_shared<QImage>();
+	_view = view;
+	return view;
+}
+
+std::shared_ptr<QImage> CloudImage::activeView() const {
+	return _view.lock();
+}
+
+bool CloudImage::isCurrentView(const std::shared_ptr<QImage> &view) const {
+	if (!view) {
+		return empty();
+	}
+	return !view.owner_before(_view) && !_view.owner_before(view);
+}
+
+void CloudImage::setToActive(
+		not_null<Main::Session*> session,
+		QImage image) {
+	if (const auto view = activeView()) {
+		*view = image.isNull()
+			? Image::Empty()->original()
+			: std::move(image);
+		session->notifyDownloaderTaskFinished();
+	}
+}
+
+void UpdateCloudFile(
+		CloudFile &file,
+		const ImageWithLocation &data,
+		Storage::Cache::Database &cache,
+		uint8 cacheTag,
+		Fn<void(FileOrigin)> restartLoader,
+		Fn<void(QImage, QByteArray)> usePreloaded) {
+	if (!data.location.valid()) {
+		if (data.progressivePartSize && !file.location.valid()) {
+			file.progressivePartSize = data.progressivePartSize;
+		}
+		if (data.location.width()
+			&& data.location.height()
+			&& !file.location.valid()
+			&& !file.location.width()) {
+			file.location = data.location;
+		}
+		return;
+	}
+
+	const auto needStickerThumbnailUpdate = [&] {
+		const auto was = std::get_if<StorageFileLocation>(
+			&file.location.file().data);
+		const auto now = std::get_if<StorageFileLocation>(
+			&data.location.file().data);
+		using Type = StorageFileLocation::Type;
+		if (!was || !now || was->type() != Type::StickerSetThumb) {
+			return false;
+		}
+		return now->valid()
+			&& (now->type() != Type::StickerSetThumb
+				|| now->cacheKey() != was->cacheKey());
+	};
+	const auto update = !file.location.valid()
+		|| (data.location.file().cacheKey()
+			&& (!file.location.file().cacheKey()
+				|| (file.location.width() < data.location.width())
+				|| (file.location.height() < data.location.height())
+				|| needStickerThumbnailUpdate()));
+	if (!update) {
+		return;
+	}
+	auto cacheBytes = !data.bytes.isEmpty()
+		? data.bytes
+		: v::is<InMemoryLocation>(file.location.file().data)
+		? v::get<InMemoryLocation>(file.location.file().data).bytes
+		: QByteArray();
+	if (!cacheBytes.isEmpty()) {
+		if (const auto cacheKey = data.location.file().cacheKey()) {
+			cache.putIfEmpty(
+				cacheKey,
+				Storage::Cache::Database::TaggedValue(
+					std::move(cacheBytes),
+					cacheTag));
+		}
+	}
+	file.location = data.location;
+	file.byteSize = data.bytesCount;
+	if (!data.preloaded.isNull()) {
+		file.loader = nullptr;
+		if (usePreloaded) {
+			usePreloaded(data.preloaded, data.bytes);
+		}
+	} else if (file.loader) {
+		const auto origin = base::take(file.loader)->fileOrigin();
+		restartLoader(origin);
+	} else if (file.flags & CloudFile::Flag::Failed) {
+		file.flags &= ~CloudFile::Flag::Failed;
+	}
+}
+
+void LoadCloudFile(
+		not_null<Main::Session*> session,
+		CloudFile &file,
+		FileOrigin origin,
+		LoadFromCloudSetting fromCloud,
+		bool autoLoading,
+		uint8 cacheTag,
+		Fn<bool()> finalCheck,
+		Fn<void(CloudFile&)> done,
+		Fn<void(bool)> fail,
+		Fn<void()> progress,
+		int downloadFrontPartSize = 0) {
+	const auto loadSize = downloadFrontPartSize
+		? std::min(downloadFrontPartSize, file.byteSize)
+		: file.byteSize;
+	if (file.loader) {
+		if (fromCloud == LoadFromCloudOrLocal) {
+			file.loader->permitLoadFromCloud();
+		}
+		if (file.loader->loadSize() < loadSize) {
+			file.loader->increaseLoadSize(loadSize, autoLoading);
+		}
+		return;
+	} else if ((file.flags & CloudFile::Flag::Failed)
+		|| !file.location.valid()
+		|| (finalCheck && !finalCheck())) {
+		return;
+	}
+	file.flags &= ~CloudFile::Flag::Cancelled;
+	file.loader = CreateFileLoader(
+		session,
+		file.location.file(),
+		origin,
+		QString(),
+		loadSize,
+		file.byteSize,
+		UnknownFileLocation,
+		LoadToCacheAsWell,
+		fromCloud,
+		autoLoading,
+		cacheTag);
+
+	const auto finish = [done](CloudFile &file) {
+		if (!file.loader || file.loader->cancelled()) {
+			file.flags |= CloudFile::Flag::Cancelled;
+		} else {
+			file.flags |= CloudFile::Flag::Loaded;
+			done(file);
+		}
+		// NB! file.loader may be in ~FileLoader() already.
+		if (const auto loader = base::take(file.loader)) {
+			if ((file.flags & CloudFile::Flag::Cancelled)
+				&& !loader->cancelled()) {
+				loader->cancel();
+			}
+		}
+	};
+
+	file.loader->updates(
+	) | rpl::on_next_error_done([=] {
+		if (const auto onstack = progress) {
+			onstack();
+		}
+	}, [=, &file](FileLoader::Error error) {
+		finish(file);
+		file.flags |= CloudFile::Flag::Failed;
+		if (const auto onstack = fail) {
+			onstack(error.started);
+		}
+	}, [=, &file] {
+		finish(file);
+	}, file.loader->lifetime());
+
+	file.loader->start();
+}
+
+void LoadCloudFile(
+		not_null<Main::Session*> session,
+		CloudFile &file,
+		FileOrigin origin,
+		LoadFromCloudSetting fromCloud,
+		bool autoLoading,
+		uint8 cacheTag,
+		Fn<bool()> finalCheck,
+		Fn<void(QImage, QByteArray)> done,
+		Fn<void(bool)> fail,
+		Fn<void()> progress,
+		int downloadFrontPartSize) {
+	const auto callback = [=](CloudFile &file) {
+		if (auto read = file.loader->imageData(); read.isNull()) {
+			file.flags |= CloudFile::Flag::Failed;
+			if (const auto onstack = fail) {
+				onstack(true);
+			}
+		} else if (const auto onstack = done) {
+			onstack(std::move(read), file.loader->bytes());
+		}
+	};
+	LoadCloudFile(
+		session,
+		file,
+		origin,
+		fromCloud,
+		autoLoading,
+		cacheTag,
+		finalCheck,
+		callback,
+		std::move(fail),
+		std::move(progress),
+		downloadFrontPartSize);
+}
+
+void LoadCloudFile(
+		not_null<Main::Session*> session,
+		CloudFile &file,
+		FileOrigin origin,
+		LoadFromCloudSetting fromCloud,
+		bool autoLoading,
+		uint8 cacheTag,
+		Fn<bool()> finalCheck,
+		Fn<void(QByteArray)> done,
+		Fn<void(bool)> fail,
+		Fn<void()> progress) {
+	const auto callback = [=](CloudFile &file) {
+		if (auto bytes = file.loader->bytes(); bytes.isEmpty()) {
+			file.flags |= CloudFile::Flag::Failed;
+			if (const auto onstack = fail) {
+				onstack(true);
+			}
+		} else if (const auto onstack = done) {
+			onstack(std::move(bytes));
+		}
+	};
+	LoadCloudFile(
+		session,
+		file,
+		origin,
+		fromCloud,
+		autoLoading,
+		cacheTag,
+		finalCheck,
+		callback,
+		std::move(fail),
+		std::move(progress));
+}
+
+} // namespace Data