Move MTP::Instance to Main::Account.

Telegram/SourceFiles/main/main_account.cpp

@@ -7,28 +7,113 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 */
 #include "main/main_account.h"
 
-#include "auth_session.h"
 #include "core/application.h"
+#include "core/launcher.h"
+#include "core/shortcuts.h"
+#include "storage/serialize_common.h"
+#include "storage/localstorage.h"
+#include "data/data_session.h"
+#include "data/data_user.h"
+#include "window/window_controller.h"
+#include "media/audio/media_audio.h"
+#include "mainwidget.h"
+#include "observer_peer.h"
+#include "auth_session.h"
 
 namespace Main {
 
 Account::Account(const QString &dataName) {
+	watchProxyChanges();
+	watchSessionChanges();
 }
 
-Account::~Account() {
+Account::~Account() = default;
+
+void Account::watchProxyChanges() {
+	using ProxyChange = Core::Application::ProxyChange;
+
+	Core::App().proxyChanges(
+	) | rpl::start_with_next([=](const ProxyChange &change) {
+		const auto key = [&](const ProxyData &proxy) {
+			return (proxy.type == ProxyData::Type::Mtproto)
+				? std::make_pair(proxy.host, proxy.port)
+				: std::make_pair(QString(), uint32(0));
+		};
+		if (_mtp) {
+			_mtp->restart();
+			if (key(change.was) != key(change.now)) {
+				_mtp->reInitConnection(_mtp->mainDcId());
+			}
+		}
+		if (_mtpForKeysDestroy) {
+			_mtpForKeysDestroy->restart();
+		}
+	}, _lifetime);
+}
+
+void Account::watchSessionChanges() {
+	sessionChanges(
+	) | rpl::start_with_next([=] {
+		crl::on_main(this, [=] {
+			const auto phone = sessionExists()
+				? session().user()->phone()
+				: QString();
+			const auto support = sessionExists() && session().supportMode();
+			if (cLoggedPhoneNumber() != phone) {
+				cSetLoggedPhoneNumber(phone);
+				if (_mtp) {
+					_mtp->setUserPhone(phone);
+				}
+				Local::writeSettings();
+			}
+			if (_mtp) {
+				_mtp->requestConfig();
+			}
+			Shortcuts::ToggleSupportShortcuts(support);
+			Platform::SetApplicationIcon(Window::CreateIcon(this));
+		});
+	}, _lifetime);
 }
 
 void Account::createSession(const MTPUser &user) {
+	Expects(_mtp != nullptr);
 	Expects(_session == nullptr);
 	Expects(_sessionValue.current() == nullptr);
 
+	_mtp->setUpdatesHandler(::rpcDone([](
+			const mtpPrime *from,
+			const mtpPrime *end) {
+		if (const auto main = App::main()) {
+			return main->updateReceived(from, end);
+		}
+		return true;
+	}));
+	_mtp->setGlobalFailHandler(::rpcFail([=](const RPCError &error) {
+		if (sessionExists()) {
+			crl::on_main(&session(), [=] { logOut(); });
+		}
+		return true;
+	}));
+
 	_session = std::make_unique<AuthSession>(this, user);
 	_sessionValue = _session.get();
 }
 
 void Account::destroySession() {
+	_storedAuthSession.reset();
+	_authSessionUserId = 0;
+	_authSessionUserSerialized = {};
+	if (!sessionExists()) {
+		return;
+	}
+	session().data().clearLocalStorage();
+
+	_mtp->clearGlobalHandlers();
+
 	_sessionValue = nullptr;
 	_session = nullptr;
+
+	Notify::unreadCounterUpdated();
 }
 
 bool Account::sessionExists() const {
@@ -41,6 +126,12 @@ AuthSession &Account::session() {
 	return *_sessionValue.current();
 }
 
+const AuthSession &Account::session() const {
+	Expects(sessionExists());
+
+	return *_sessionValue.current();
+}
+
 rpl::producer<AuthSession*> Account::sessionValue() const {
 	return _sessionValue.value();
 }
@@ -49,8 +140,343 @@ rpl::producer<AuthSession*> Account::sessionChanges() const {
 	return _sessionValue.changes();
 }
 
-MTP::Instance *Account::mtp() {
-	return MTP::MainInstance();
+rpl::producer<MTP::Instance*> Account::mtpValue() const {
+	return _mtpValue.value();
+}
+
+rpl::producer<MTP::Instance*> Account::mtpChanges() const {
+	return _mtpValue.changes();
+}
+
+void Account::setMtpMainDcId(MTP::DcId mainDcId) {
+	Expects(!_mtp);
+
+	_mtpConfig.mainDcId = mainDcId;
+}
+
+void Account::setMtpKey(MTP::DcId dcId, const MTP::AuthKey::Data &keyData) {
+	Expects(!_mtp);
+
+	_mtpConfig.keys.push_back(std::make_shared<MTP::AuthKey>(
+		MTP::AuthKey::Type::ReadFromFile,
+		dcId,
+		keyData));
+}
+
+QByteArray Account::serializeMtpAuthorization() const {
+	const auto serialize = [&](
+			MTP::DcId mainDcId,
+			const MTP::AuthKeysList &keys,
+			const MTP::AuthKeysList &keysToDestroy) {
+		const auto keysSize = [](auto &list) {
+			const auto keyDataSize = MTP::AuthKey::Data().size();
+			return sizeof(qint32)
+				+ list.size() * (sizeof(qint32) + keyDataSize);
+		};
+		const auto writeKeys = [](
+				QDataStream &stream,
+				const MTP::AuthKeysList &keys) {
+			stream << qint32(keys.size());
+			for (const auto &key : keys) {
+				stream << qint32(key->dcId());
+				key->write(stream);
+			}
+		};
+
+		auto result = QByteArray();
+		auto size = sizeof(qint32) + sizeof(qint32); // userId + mainDcId
+		size += keysSize(keys) + keysSize(keysToDestroy);
+		result.reserve(size);
+		{
+			QDataStream stream(&result, QIODevice::WriteOnly);
+			stream.setVersion(QDataStream::Qt_5_1);
+
+			const auto currentUserId = sessionExists()
+				? session().userId()
+				: 0;
+			stream << qint32(currentUserId) << qint32(mainDcId);
+			writeKeys(stream, keys);
+			writeKeys(stream, keysToDestroy);
+
+			DEBUG_LOG(("MTP Info: Keys written, userId: %1, dcId: %2").arg(currentUserId).arg(mainDcId));
+		}
+		return result;
+	};
+	if (_mtp) {
+		const auto keys = _mtp->getKeysForWrite();
+		const auto keysToDestroy = _mtpForKeysDestroy
+			? _mtpForKeysDestroy->getKeysForWrite()
+			: MTP::AuthKeysList();
+		return serialize(_mtp->mainDcId(), keys, keysToDestroy);
+	}
+	const auto &keys = _mtpConfig.keys;
+	const auto &keysToDestroy = _mtpKeysToDestroy;
+	return serialize(_mtpConfig.mainDcId, keys, keysToDestroy);
+}
+
+void Account::setAuthSessionUserId(UserId userId) {
+	Expects(!sessionExists());
+
+	_authSessionUserId = userId;
+}
+
+void Account::setAuthSessionFromStorage(
+		std::unique_ptr<AuthSessionSettings> data,
+		QByteArray &&selfSerialized,
+		int32 selfStreamVersion) {
+	Expects(!sessionExists());
+
+	DEBUG_LOG(("authSessionUserSerialized set: %1"
+		).arg(selfSerialized.size()));
+
+	_storedAuthSession = std::move(data);
+	_authSessionUserSerialized = std::move(selfSerialized);
+	_authSessionUserStreamVersion = selfStreamVersion;
+}
+
+AuthSessionSettings *Account::getAuthSessionSettings() {
+	if (_authSessionUserId) {
+		return _storedAuthSession ? _storedAuthSession.get() : nullptr;
+	} else if (sessionExists()) {
+		return &session().settings();
+	}
+	return nullptr;
+}
+
+void Account::setMtpAuthorization(const QByteArray &serialized) {
+	Expects(!_mtp);
+
+	QDataStream stream(serialized);
+	stream.setVersion(QDataStream::Qt_5_1);
+
+	auto userId = Serialize::read<qint32>(stream);
+	auto mainDcId = Serialize::read<qint32>(stream);
+	if (stream.status() != QDataStream::Ok) {
+		LOG(("MTP Error: "
+			"Could not read main fields from mtp authorization."));
+		return;
+	}
+
+	setAuthSessionUserId(userId);
+	_mtpConfig.mainDcId = mainDcId;
+
+	const auto readKeys = [&stream](auto &keys) {
+		const auto count = Serialize::read<qint32>(stream);
+		if (stream.status() != QDataStream::Ok) {
+			LOG(("MTP Error: "
+				"Could not read keys count from mtp authorization."));
+			return;
+		}
+		keys.reserve(count);
+		for (auto i = 0; i != count; ++i) {
+			const auto dcId = Serialize::read<qint32>(stream);
+			const auto keyData = Serialize::read<MTP::AuthKey::Data>(stream);
+			if (stream.status() != QDataStream::Ok) {
+				LOG(("MTP Error: "
+					"Could not read key from mtp authorization."));
+				return;
+			}
+			keys.push_back(std::make_shared<MTP::AuthKey>(MTP::AuthKey::Type::ReadFromFile, dcId, keyData));
+		}
+	};
+	readKeys(_mtpConfig.keys);
+	readKeys(_mtpKeysToDestroy);
+	LOG(("MTP Info: "
+		"read keys, current: %1, to destroy: %2"
+		).arg(_mtpConfig.keys.size()
+		).arg(_mtpKeysToDestroy.size()));
+}
+
+void Account::startMtp() {
+	Expects(!_mtp);
+
+	auto config = base::take(_mtpConfig);
+	config.deviceModel = Core::App().launcher()->deviceModel();
+	config.systemVersion = Core::App().launcher()->systemVersion();
+	_mtp = std::make_unique<MTP::Instance>(
+		Core::App().dcOptions(),
+		MTP::Instance::Mode::Normal,
+		std::move(config));
+	_mtp->setUserPhone(cLoggedPhoneNumber());
+	_mtpConfig.mainDcId = _mtp->mainDcId();
+
+	_mtp->setStateChangedHandler([](MTP::ShiftedDcId dc, int32 state) {
+		if (dc == MTP::maindc()) {
+			Global::RefConnectionTypeChanged().notify();
+		}
+	});
+	_mtp->setSessionResetHandler([](MTP::ShiftedDcId shiftedDcId) {
+		if (App::main() && shiftedDcId == MTP::maindc()) {
+			App::main()->getDifference();
+		}
+	});
+
+	if (!_mtpKeysToDestroy.empty()) {
+		destroyMtpKeys(base::take(_mtpKeysToDestroy));
+	}
+
+	if (_authSessionUserId) {
+		DEBUG_LOG(("authSessionUserSerialized.size: %1"
+			).arg(_authSessionUserSerialized.size()));
+		QDataStream peekStream(_authSessionUserSerialized);
+		const auto phone = Serialize::peekUserPhone(
+			_authSessionUserStreamVersion,
+			peekStream);
+		const auto flags = MTPDuser::Flag::f_self | (phone.isEmpty()
+			? MTPDuser::Flag()
+			: MTPDuser::Flag::f_phone);
+		createSession(MTP_user(
+			MTP_flags(flags),
+			MTP_int(base::take(_authSessionUserId)),
+			MTPlong(), // access_hash
+			MTPstring(), // first_name
+			MTPstring(), // last_name
+			MTPstring(), // username
+			MTP_string(phone),
+			MTPUserProfilePhoto(),
+			MTPUserStatus(),
+			MTPint(), // bot_info_version
+			MTPstring(), // restriction_reason
+			MTPstring(), // bot_inline_placeholder
+			MTPstring())); // lang_code
+		Local::readSelf(
+			base::take(_authSessionUserSerialized),
+			base::take(_authSessionUserStreamVersion));
+	}
+	if (_storedAuthSession) {
+		if (sessionExists()) {
+			session().moveSettingsFrom(std::move(*_storedAuthSession));
+		}
+		_storedAuthSession.reset();
+	}
+
+	if (sessionExists()) {
+		// Skip all pending self updates so that we won't Local::writeSelf.
+		Notify::peerUpdatedSendDelayed();
+	}
+
+	_mtpValue = _mtp.get();
+}
+
+
+void Account::logOut() {
+	if (_mtp) {
+		_mtp->logout(::rpcDone([=] {
+			loggedOut();
+		}), ::rpcFail([=] {
+			loggedOut();
+			return true;
+		}));
+	} else {
+		// We log out because we've forgotten passcode.
+		// So we just start mtproto from scratch.
+		startMtp();
+		loggedOut();
+	}
+}
+
+void Account::forcedLogOut() {
+	if (sessionExists()) {
+		resetAuthorizationKeys();
+		loggedOut();
+	}
+}
+
+void Account::loggedOut() {
+	if (Global::LocalPasscode()) {
+		Global::SetLocalPasscode(false);
+		Global::RefLocalPasscodeChanged().notify();
+	}
+	Core::App().unlockPasscode();
+	Core::App().unlockTerms();
+	Media::Player::mixer()->stopAndClear();
+	Global::SetVoiceMsgPlaybackDoubled(false);
+	if (const auto window = Core::App().activeWindow()) {
+		window->tempDirDelete(Local::ClearManagerAll);
+		window->setupIntro();
+	}
+	destroySession();
+	Local::reset();
+
+	cSetOtherOnline(0);
+	Images::ClearRemote();
+}
+
+void Account::destroyMtpKeys(MTP::AuthKeysList &&keys) {
+	if (keys.empty()) {
+		return;
+	}
+	if (_mtpForKeysDestroy) {
+		_mtpForKeysDestroy->addKeysForDestroy(std::move(keys));
+		Local::writeMtpData();
+		return;
+	}
+	auto destroyConfig = MTP::Instance::Config();
+	destroyConfig.mainDcId = MTP::Instance::Config::kNoneMainDc;
+	destroyConfig.keys = std::move(keys);
+	destroyConfig.deviceModel = Core::App().launcher()->deviceModel();
+	destroyConfig.systemVersion = Core::App().launcher()->systemVersion();
+	_mtpForKeysDestroy = std::make_unique<MTP::Instance>(
+		Core::App().dcOptions(),
+		MTP::Instance::Mode::KeysDestroyer,
+		std::move(destroyConfig));
+	QObject::connect(
+		_mtpForKeysDestroy.get(),
+		&MTP::Instance::allKeysDestroyed,
+		[=] { allKeysDestroyed(); });
+}
+
+void Account::allKeysDestroyed() {
+	LOG(("MTP Info: all keys scheduled for destroy are destroyed."));
+	crl::on_main(this, [=] {
+		_mtpForKeysDestroy = nullptr;
+		Local::writeMtpData();
+	});
+}
+
+void Account::suggestMainDcId(MTP::DcId mainDcId) {
+	Expects(_mtp != nullptr);
+
+	_mtp->suggestMainDcId(mainDcId);
+	if (_mtpConfig.mainDcId != MTP::Instance::Config::kNotSetMainDc) {
+		_mtpConfig.mainDcId = mainDcId;
+	}
+}
+
+void Account::destroyStaleAuthorizationKeys() {
+	Expects(_mtp != nullptr);
+
+	for (const auto &key : _mtp->getKeysForWrite()) {
+		// Disable this for now.
+		if (key->type() == MTP::AuthKey::Type::ReadFromFile) {
+			_mtpKeysToDestroy = _mtp->getKeysForWrite();
+			LOG(("MTP Info: destroying stale keys, count: %1"
+				).arg(_mtpKeysToDestroy.size()));
+			resetAuthorizationKeys();
+			return;
+		}
+	}
+}
+
+void Account::configUpdated() {
+	_configUpdates.fire({});
+}
+
+rpl::producer<> Account::configUpdates() const {
+	return _configUpdates.events();
+}
+
+void Account::resetAuthorizationKeys() {
+	_mtp = nullptr;
+	_mtpValue = _mtp.get();
+	startMtp();
+	Local::writeMtpData();
+}
+
+void Account::clearMtp() {
+	_mtp = nullptr;
+	_mtpForKeysDestroy = nullptr;
+	_mtpValue = _mtp.get();
 }
 
 } // namespace Main

Telegram/SourceFiles/main/main_account.h

@@ -7,11 +7,15 @@ https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 */
 #pragma once
 
+#include "mtproto/auth_key.h"
+#include "base/weak_ptr.h"
+
 class AuthSession;
+class AuthSessionSettings;
 
 namespace Main {
 
-class Account final {
+class Account final : public base::has_weak_ptr {
 public:
 	explicit Account(const QString &dataName);
 	~Account();
@@ -22,17 +26,69 @@ public:
 	void createSession(const MTPUser &user);
 	void destroySession();
 
+	void logOut();
+	void forcedLogOut();
+
 	[[nodiscard]] bool sessionExists() const;
 	[[nodiscard]] AuthSession &session();
+	[[nodiscard]] const AuthSession &session() const;
 	[[nodiscard]] rpl::producer<AuthSession*> sessionValue() const;
 	[[nodiscard]] rpl::producer<AuthSession*> sessionChanges() const;
 
-	[[nodiscard]] MTP::Instance *mtp();
+	[[nodiscard]] MTP::Instance *mtp() {
+		return _mtp.get();
+	}
+	[[nodiscard]] rpl::producer<MTP::Instance*> mtpValue() const;
+	[[nodiscard]] rpl::producer<MTP::Instance*> mtpChanges() const;
+
+	// Set from legacy storage.
+	void setMtpMainDcId(MTP::DcId mainDcId);
+	void setMtpKey(MTP::DcId dcId, const MTP::AuthKey::Data &keyData);
+	void setAuthSessionUserId(UserId userId);
+	void setAuthSessionFromStorage(
+		std::unique_ptr<AuthSessionSettings> data,
+		QByteArray &&selfSerialized,
+		int32 selfStreamVersion);
+	[[nodiscard]] AuthSessionSettings *getAuthSessionSettings();
+
+	// Serialization.
+	[[nodiscard]] QByteArray serializeMtpAuthorization() const;
+	void setMtpAuthorization(const QByteArray &serialized);
+
+	void startMtp();
+	void suggestMainDcId(MTP::DcId mainDcId);
+	void destroyStaleAuthorizationKeys();
+	void configUpdated();
+	[[nodiscard]] rpl::producer<> configUpdates() const;
+	void clearMtp();
 
 private:
+	void watchProxyChanges();
+	void watchSessionChanges();
+
+	void destroyMtpKeys(MTP::AuthKeysList &&keys);
+	void allKeysDestroyed();
+	void resetAuthorizationKeys();
+
+	void loggedOut();
+
+	std::unique_ptr<MTP::Instance> _mtp;
+	rpl::variable<MTP::Instance*> _mtpValue;
+	std::unique_ptr<MTP::Instance> _mtpForKeysDestroy;
+	rpl::event_stream<> _configUpdates;
+
 	std::unique_ptr<AuthSession> _session;
 	rpl::variable<AuthSession*> _sessionValue;
 
+	UserId _authSessionUserId = 0;
+	QByteArray _authSessionUserSerialized;
+	int32 _authSessionUserStreamVersion = 0;
+	std::unique_ptr<AuthSessionSettings> _storedAuthSession;
+	MTP::Instance::Config _mtpConfig;
+	MTP::AuthKeysList _mtpKeysToDestroy;
+
+	rpl::lifetime _lifetime;
+
 };
 
 } // namespace Main