init

Telegram/SourceFiles/mtproto/dedicated_file_loader.h

@@ -0,0 +1,207 @@
+/*
+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
+*/
+#pragma once
+
+#include "mtproto/mtp_instance.h"
+
+namespace Main {
+class Session;
+} // namespace Main
+
+namespace MTP {
+
+class WeakInstance final : private QObject {
+public:
+	explicit WeakInstance(base::weak_ptr<Main::Session> session);
+
+	template <typename Request>
+	void send(
+		const Request &request,
+		Fn<void(const typename Request::ResponseType &result)> done,
+		Fn<void(const Error &error)> fail,
+		ShiftedDcId dcId = 0);
+
+	[[nodiscard]] base::weak_ptr<Main::Session> session() const;
+	[[nodiscard]] bool valid() const;
+	[[nodiscard]] Instance *instance() const;
+
+	~WeakInstance();
+
+private:
+	void die();
+	bool removeRequest(mtpRequestId requestId);
+	void reportUnavailable(Fn<void(const Error &error)> callback);
+
+	base::weak_ptr<Main::Session> _session;
+	Instance *_instance = nullptr;
+	std::map<mtpRequestId, Fn<void(const Error &)>> _requests;
+	rpl::lifetime _lifetime;
+
+};
+
+class AbstractDedicatedLoader : public base::has_weak_ptr {
+public:
+	AbstractDedicatedLoader(const QString &filepath, int chunkSize);
+
+	static constexpr auto kChunkSize = 128 * 1024;
+	static constexpr auto kMaxFileSize = 256 * 1024 * 1024;
+
+	struct Progress {
+		int64 already = 0;
+		int64 size = 0;
+
+		inline bool operator<(const Progress &other) const {
+			return (already < other.already)
+				|| (already == other.already && size < other.size);
+		}
+		inline bool operator==(const Progress &other) const {
+			return (already == other.already) && (size == other.size);
+		}
+	};
+
+	void start();
+	void wipeFolder();
+	void wipeOutput();
+
+	int64 alreadySize() const;
+	int64 totalSize() const;
+
+	rpl::producer<Progress> progress() const;
+	rpl::producer<QString> ready() const;
+	rpl::producer<> failed() const;
+
+	rpl::lifetime &lifetime();
+
+	virtual ~AbstractDedicatedLoader() = default;
+
+protected:
+	void threadSafeFailed();
+
+	// Single threaded.
+	void writeChunk(bytes::const_span data, int totalSize);
+
+private:
+	virtual void startLoading() = 0;
+
+	bool validateOutput();
+	void threadSafeProgress(Progress progress);
+	void threadSafeReady();
+
+	QString _filepath;
+	int _chunkSize = 0;
+
+	QFile _output;
+	int64 _alreadySize = 0;
+	int64 _totalSize = 0;
+	mutable QMutex _sizesMutex;
+	rpl::event_stream<Progress> _progress;
+	rpl::event_stream<QString> _ready;
+	rpl::event_stream<> _failed;
+
+	rpl::lifetime _lifetime;
+
+};
+
+class DedicatedLoader : public AbstractDedicatedLoader {
+public:
+	struct Location {
+		QString username;
+		int32 postId = 0;
+	};
+	struct File {
+		QString name;
+		int64 size = 0;
+		DcId dcId = 0;
+		MTPInputFileLocation location;
+	};
+
+	DedicatedLoader(
+		base::weak_ptr<Main::Session> session,
+		const QString &folder,
+		const File &file);
+
+private:
+	struct Request {
+		int64 offset = 0;
+		QByteArray bytes;
+	};
+	void startLoading() override;
+	void sendRequest();
+	void gotPart(int offset, const MTPupload_File &result);
+	Fn<void(const Error &)> failHandler();
+
+	static constexpr auto kRequestsCount = 2;
+	static constexpr auto kNextRequestDelay = crl::time(20);
+
+	std::deque<Request> _requests;
+	int64 _size = 0;
+	int64 _offset = 0;
+	DcId _dcId = 0;
+	MTPInputFileLocation _location;
+	WeakInstance _mtp;
+
+};
+
+void ResolveChannel(
+	not_null<MTP::WeakInstance*> mtp,
+	const QString &username,
+	Fn<void(const MTPInputChannel &channel)> done,
+	Fn<void()> fail);
+
+std::optional<MTPMessage> GetMessagesElement(
+	const MTPmessages_Messages &list);
+
+void StartDedicatedLoader(
+	not_null<MTP::WeakInstance*> mtp,
+	const DedicatedLoader::Location &location,
+	const QString &folder,
+	Fn<void(std::unique_ptr<DedicatedLoader>)> ready);
+
+template <typename Request>
+void WeakInstance::send(
+		const Request &request,
+		Fn<void(const typename Request::ResponseType &result)> done,
+		Fn<void(const Error &error)> fail,
+		MTP::ShiftedDcId dcId) {
+	using Result = typename Request::ResponseType;
+	if (!valid()) {
+		reportUnavailable(fail);
+		return;
+	}
+	const auto onDone = crl::guard((QObject*)this, [=](
+			const Response &response) {
+		auto result = Result();
+		auto from = response.reply.constData();
+		if (!result.read(from, from + response.reply.size())) {
+			return false;
+		}
+		if (removeRequest(response.requestId)) {
+			done(result);
+		}
+		return true;
+	});
+	const auto onFail = crl::guard((QObject*)this, [=](
+			const Error &error,
+			const Response &response) {
+		if (MTP::IsDefaultHandledError(error)) {
+			return false;
+		}
+		if (removeRequest(response.requestId)) {
+			fail(error);
+		}
+		return true;
+	});
+	const auto requestId = _instance->send(
+		request,
+		std::move(onDone),
+		std::move(onFail),
+		dcId);
+	_requests.emplace(requestId, fail);
+}
+
+} // namespace MTP