No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelogs/51.add b/changelogs/51.add
	new file mode 100644
	index 0000000..576bda7
	--- /dev/null
	+++ b/changelogs/51.add
	@@ -0,0 +1 @@
	+Use libkazv push rules to determine whether to notify for an event
	diff --git a/src/contents/ui/Notifier.qml b/src/contents/ui/Notifier.qml
	index 14a430e..d8024f7 100644
	--- a/src/contents/ui/Notifier.qml
	+++ b/src/contents/ui/Notifier.qml
	@@ -1,37 +1,42 @@
	/*
	* This file is part of kazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	import QtQuick 2.15

	import 'matrix-helpers.js' as Helpers
	import '.' as Kazv

	QtObject {
	id: notifier
	property var notificationComp: Component {
	Kazv.MessageNotification {
	autoDelete: true
	}
	}

	property var conn: Connections {
	target: matrixSdk
	function onReceivedMessage(roomId, eventId) {
	const roomList = matrixSdk.roomList();
	const room = roomList.room(roomId);
	const event = room.messageById(eventId);
	const sender = room.member(event.sender);
	const senderName = sender.name \|\| sender.userId \|\| '';
	- const notification = notificationComp.createObject(notifier);
	- notification.title = Helpers.roomNameOrHeroes(room, l10n);
	- const message = event.content.body;
	- notification.text = message
	- ? l10n.get('notification-message', { user: senderName, message })
	- : l10n.get('notification-message-no-content', { user: senderName });
	- notification.sendEvent();
	+ if (matrixSdk.shouldNotify(event)) {
	+ console.debug('Push rules say we should notify this');
	+ const notification = notificationComp.createObject(notifier);
	+ notification.title = Helpers.roomNameOrHeroes(room, l10n);
	+ const message = event.content.body;
	+ notification.text = message
	+ ? l10n.get('notification-message', { user: senderName, message })
	+ : l10n.get('notification-message-no-content', { user: senderName });
	+ notification.sendEvent();
	+ } else {
	+ console.debug('Push rules say we should not notify this');
	+ }
	}
	}
	}
	diff --git a/src/matrix-event.cpp b/src/matrix-event.cpp
	index fd80978..ed32ce0 100644
	--- a/src/matrix-event.cpp
	+++ b/src/matrix-event.cpp
	@@ -1,90 +1,95 @@
	/*
	* This file is part of kazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/
	#include <libkazv-config.hpp>

	#include <immer/config.hpp> // https://github.com/arximboldi/immer/issues/168

	#include "matrix-event.hpp"

	#include "helper.hpp"

	using namespace Kazv;

	static std::optional<LocalEchoDesc> getLocalEcho(std::variant<Event, LocalEchoDesc> event)
	{
	if (std::holds_alternative<LocalEchoDesc>(event)) {
	return std::get<LocalEchoDesc>(event);
	} else {
	return std::nullopt;
	}
	}

	static Event getEvent(std::variant<Event, LocalEchoDesc> event)
	{
	if (std::holds_alternative<LocalEchoDesc>(event)) {
	return std::get<LocalEchoDesc>(event).event;
	} else {
	return std::get<Event>(event);
	}
	}

	MatrixEvent::MatrixEvent(lager::reader<std::variant<Event, LocalEchoDesc>> event, QObject *parent)
	: QObject(parent)
	, m_localEcho(event.map(getLocalEcho))
	, m_event(event.map(getEvent))
	, LAGER_QT(eventId)(m_event.xform(zug::map([](Event e) { return e.id(); }) \| strToQt))
	, LAGER_QT(sender)(m_event.xform(zug::map([](Event e) { return e.sender(); }) \| strToQt))
	, LAGER_QT(type)(m_event.xform(zug::map([](Event e) { return e.type(); }) \| strToQt))
	, LAGER_QT(stateKey)(m_event.xform(zug::map([](Event e) { return e.stateKey(); }) \| strToQt))
	, LAGER_QT(content)(m_event.xform(zug::map([](Event e) { return e.content().get().get<QJsonObject>(); })))
	, LAGER_QT(encrypted)(m_event.xform(zug::map([](Event e) { return e.encrypted(); })))
	, LAGER_QT(decrypted)(m_event.map([](Event e) { return e.decrypted(); }))
	, LAGER_QT(isState)(m_event.map([](Event e) { return e.isState(); }))
	, LAGER_QT(unsignedData)(m_event.map([](Event e) {
	auto j = e.raw();
	if (j.get().contains("unsigned")) {
	return j.get()["unsigned"].template get<QJsonObject>();
	} else {
	return QJsonObject();
	}
	}))
	, LAGER_QT(isLocalEcho)(m_localEcho.map([](const auto &maybe) { return maybe.has_value(); }))
	, LAGER_QT(isSending)(m_localEcho.map([](const auto &maybe) {
	return maybe.has_value() && maybe.value().status == LocalEchoDesc::Sending;
	}))
	, LAGER_QT(isFailed)(m_localEcho.map([](const auto &maybe) {
	return maybe.has_value() && maybe.value().status == LocalEchoDesc::Failed;
	}))
	, LAGER_QT(txnId)(m_localEcho.map([](const auto &maybe) {
	return maybe.has_value() ? QString::fromStdString(maybe.value().txnId) : QStringLiteral("");
	}))
	, LAGER_QT(redacted)(m_event.map([](const auto &e) {
	return e.redacted();
	}))
	, LAGER_QT(originalSource)(m_event.map([](Event e) {
	return e.originalJson().get().template get<QJsonObject>();
	}))
	, LAGER_QT(decryptedSource)(m_event.map([](Event e) {
	return e.decrypted() ? e.raw().get().template get<QJsonObject>() : QJsonObject();
	}))
	, LAGER_QT(replyingToEventId)(m_event.map([](Event e) {
	return e.replyingTo();
	}).xform(strToQt))
	, LAGER_QT(relationType)(m_event.map([](Event e) {
	return e.relationship().first;
	}).xform(strToQt))
	, LAGER_QT(relatedEventId)(m_event.map([](Event e) {
	return e.relationship().second;
	}).xform(strToQt))
	{
	}

	MatrixEvent::MatrixEvent(lager::reader<Event> event, QObject *parent)
	: MatrixEvent(event.map([](const auto &e) -> std::variant<Kazv::Event, Kazv::LocalEchoDesc> { return e; }), parent)
	{
	}

	MatrixEvent::~MatrixEvent() = default;
	+
	+Kazv::Event MatrixEvent::underlyingEvent() const
	+{
	+ return m_event.get();
	+}
	diff --git a/src/matrix-event.hpp b/src/matrix-event.hpp
	index 54d6abe..efa6c58 100644
	--- a/src/matrix-event.hpp
	+++ b/src/matrix-event.hpp
	@@ -1,54 +1,56 @@
	/*
	* This file is part of kazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#pragma once
	#include <libkazv-config.hpp>

	#include <immer/config.hpp> // https://github.com/arximboldi/immer/issues/168

	#include <QObject>
	#include <QQmlEngine>

	#include <lager/extra/qt.hpp>

	#include <client/room/room.hpp>

	#include "qt-json.hpp"

	class MatrixEvent : public QObject
	{
	Q_OBJECT
	QML_ELEMENT
	QML_UNCREATABLE("")

	lager::reader<std::optional<Kazv::LocalEchoDesc>> m_localEcho;
	lager::reader<Kazv::Event> m_event;

	public:
	explicit MatrixEvent(lager::reader<std::variant<Kazv::Event, Kazv::LocalEchoDesc>> event, QObject *parent = 0);
	explicit MatrixEvent(lager::reader<Kazv::Event> event, QObject *parent = 0);
	~MatrixEvent() override;

	LAGER_QT_READER(QString, eventId);
	LAGER_QT_READER(QString, sender);
	LAGER_QT_READER(QString, type);
	LAGER_QT_READER(QString, stateKey);
	LAGER_QT_READER(QJsonObject, content);
	LAGER_QT_READER(bool, encrypted);
	LAGER_QT_READER(bool, decrypted);
	LAGER_QT_READER(bool, isState);
	LAGER_QT_READER(QJsonObject, unsignedData);
	LAGER_QT_READER(bool, isLocalEcho);
	LAGER_QT_READER(bool, isSending);
	LAGER_QT_READER(bool, isFailed);
	LAGER_QT_READER(QString, txnId);
	LAGER_QT_READER(bool, redacted);
	LAGER_QT_READER(QJsonObject, originalSource);
	LAGER_QT_READER(QJsonObject, decryptedSource);
	LAGER_QT_READER(QString, replyingToEventId);
	LAGER_QT_READER(QString, relationType);
	LAGER_QT_READER(QString, relatedEventId);
	+
	+ Kazv::Event underlyingEvent() const;
	};
	diff --git a/src/matrix-sdk.cpp b/src/matrix-sdk.cpp
	index a6831d9..ec7edea 100644
	--- a/src/matrix-sdk.cpp
	+++ b/src/matrix-sdk.cpp
	@@ -1,569 +1,583 @@
	/*
	* This file is part of kazv.
	* SPDX-FileCopyrightText: 2020-2023 Tusooa Zhu <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/
	#include <libkazv-config.hpp>
	#include <immer/config.hpp> // https://github.com/arximboldi/immer/issues/168

	#include <boost/archive/text_oarchive.hpp>
	#include <boost/archive/text_iarchive.hpp>
	#include <fstream>
	#include <filesystem>
	#include <chrono>

	#include <QMutex>
	#include <QMutexLocker>
	#include <QtConcurrent>
	#include <QThreadPool>

	#include <KConfig>
	#include <KConfigGroup>

	#include <eventemitter/lagerstoreeventemitter.hpp>
	#include <client/sdk.hpp>
	+#include <client/notification-handler.hpp>
	#include <base/descendent.hpp>

	#include <zug/util.hpp>
	#include <lager/event_loop/qt.hpp>

	#include "matrix-sdk.hpp"
	#include "matrix-room-list.hpp"
	#include "matrix-promise.hpp"
	+#include "matrix-event.hpp"
	#include "helper.hpp"
	#include "kazv-path-config.hpp"
	#include "kazv-version.hpp"
	#include "qt-json.hpp"
	#include "qt-rand-adapter.hpp"
	#include "qt-promise-handler.hpp"
	#include "qt-job-handler.hpp"
	#include "device-mgmt/matrix-device-list.hpp"
	#include "kazv-log.hpp"

	using namespace Kazv;

	// Sdk with qt event loop, identity transform and no enhancers
	using SdkT =
	decltype(makeSdk(
	SdkModel{},
	detail::declref<JobInterface>(),
	detail::declref<EventInterface>(),
	QtPromiseHandler(detail::declref<QObject>()),
	zug::identity,
	withRandomGenerator(detail::declref<RandomInterface>())));

	static void serializeClientToFile(Client c);

	struct MatrixSdkPrivate
	{
	MatrixSdkPrivate(MatrixSdk *q, bool testing);
	MatrixSdkPrivate(MatrixSdk *q, bool testing, SdkModel model);
	bool testing;
	RandomInterface randomGenerator;
	QThread thread;
	QThreadPool pool;
	QObject *obj;
	QtJobHandler *jobHandler;
	LagerStoreEventEmitter ee;
	LagerStoreEventEmitter::Watchable watchable;
	SdkT sdk;
	QTimer saveTimer;

	using SecondaryRootT = decltype(sdk.createSecondaryRoot(std::declval<lager::with_qt_event_loop>()));
	SecondaryRootT secondaryRoot;
	Client clientOnSecondaryRoot;
	+ NotificationHandler notificationHandler;
	void runIoContext() {
	thread.start();
	}

	void maybeSerialize()
	{
	if (!testing) {
	serializeClientToFile(clientOnSecondaryRoot);
	}
	}
	};

	class CleanupHelper : public QObject
	{
	Q_OBJECT
	public:
	explicit CleanupHelper(std::unique_ptr<MatrixSdkPrivate> d)
	: oldD(std::move(d))
	{
	connect(oldD->obj, &QObject::destroyed, this, &CleanupHelper::stopThread);
	}

	std::shared_ptr<MatrixSdkPrivate> oldD;

	void cleanup()
	{
	qCInfo(kazvLog) << "start to clean up everything";
	// Not running io_context::stop() because it will
	// disregard any remaining work guards. Here we just
	// want to end any periodic jobs but still wait for
	// current remaining jobs.
	oldD->clientOnSecondaryRoot.stopSyncing();
	qCDebug(kazvLog) << "stopped syncing";
	oldD->jobHandler->deleteLater();
	qCDebug(kazvLog) << "deleted jobhandler";
	oldD->obj->deleteLater();
	qCDebug(kazvLog) << "deleted object";
	}

	void stopThread()
	{
	QTimer::singleShot(0, this, &CleanupHelper::doStopThread);
	}

	void doStopThread()
	{
	qCDebug(kazvLog) << "stopping thread";
	oldD->thread.quit();
	qCInfo(kazvLog) << "from here, the old data can be destructed";
	deleteLater();
	}
	};

	static void serializeClientToFile(Client c)
	{
	using namespace Kazv::CursorOp;
	auto userId = +c.userId();
	auto deviceId = +c.deviceId();
	if (userId.empty() \|\| deviceId.empty()) {
	qDebug() << "Not logged in, nothing to serialize";
	return;
	}

	using StdPath = std::filesystem::path;
	auto userDataDir = StdPath(kazvUserDataDir().toStdString());
	auto sessionDir = userDataDir / "sessions"
	/ userId / deviceId;

	auto storeFile = sessionDir / "store";

	auto metadataFile = sessionDir / "metadata";

	qDebug() << "storeFile=" << QString::fromStdString(storeFile.native());

	std::error_code err;
	if ((! std::filesystem::create_directories(sessionDir, err))
	&& err) {
	qDebug() << "Unable to create sessionDir";
	return;
	}

	{
	auto storeStream = std::ofstream(storeFile);
	if (! storeStream) {
	qDebug() << "Unable to open storeFile";
	return;
	}
	using OAr = boost::archive::text_oarchive;
	auto archive = OAr{storeStream};
	c.serializeTo(archive);
	qDebug() << "Serialization done";
	}

	// store metadata
	{
	KConfig metadata(QString::fromStdString(metadataFile.native()));
	KConfigGroup mdGroup(&metadata, "Metadata");
	mdGroup.writeEntry("kazvVersion", QString::fromStdString(kazvVersionString()));
	mdGroup.writeEntry("archiveFormat", "text");
	}
	}

	MatrixSdkPrivate::MatrixSdkPrivate(MatrixSdk *q, bool testing)
	: testing(testing)
	, randomGenerator(QtRandAdapter{})
	, thread()
	, pool()
	, obj(new QObject(&thread))
	, jobHandler(new QtJobHandler(obj))
	, ee{lager::with_qt_event_loop{*obj, pool}}
	, watchable(ee.watchable())
	, sdk(makeDefaultSdkWithCryptoRandom(
	randomGenerator.generateRange<std::string>(makeDefaultSdkWithCryptoRandomSize()),
	static_cast<JobInterface &>(*jobHandler),
	static_cast<EventInterface &>(ee),
	QtPromiseHandler(*obj),
	zug::identity,
	withRandomGenerator(randomGenerator)))
	, secondaryRoot(sdk.createSecondaryRoot(lager::with_qt_event_loop{*q}))
	, clientOnSecondaryRoot(sdk.clientFromSecondaryRoot(secondaryRoot))
	+ , notificationHandler(clientOnSecondaryRoot.notificationHandler())
	{
	}

	MatrixSdkPrivate::MatrixSdkPrivate(MatrixSdk *q, bool testing, SdkModel model)
	: testing(testing)
	, randomGenerator(QtRandAdapter{})
	, thread()
	, pool()
	, obj(new QObject(&thread))
	, jobHandler(new QtJobHandler(obj))
	, ee{lager::with_qt_event_loop{*obj, pool}}
	, watchable(ee.watchable())
	, sdk(makeSdk(
	model,
	static_cast<JobInterface &>(*jobHandler),
	static_cast<EventInterface &>(ee),
	QtPromiseHandler(*obj),
	zug::identity,
	withRandomGenerator(randomGenerator)))
	, secondaryRoot(sdk.createSecondaryRoot(lager::with_qt_event_loop{*q, pool}, std::move(model)))
	, clientOnSecondaryRoot(sdk.clientFromSecondaryRoot(secondaryRoot))
	+ , notificationHandler(clientOnSecondaryRoot.notificationHandler())
	{
	}

	MatrixSdk::MatrixSdk(std::unique_ptr<MatrixSdkPrivate> d, QObject *parent)
	: QObject(parent)
	, m_d(std::move(d))
	{
	init();
	connect(this, &MatrixSdk::trigger,
	this, [](KazvEvent e) {
	qDebug() << "receiving trigger:";
	if (std::holds_alternative<LoginSuccessful>(e)) {
	qDebug() << "Login successful";
	}
	});
	}

	void MatrixSdk::init()
	{
	LAGER_QT(serverUrl) = m_d->clientOnSecondaryRoot.serverUrl().xform(strToQt); Q_EMIT serverUrlChanged(serverUrl());
	LAGER_QT(userId) = m_d->clientOnSecondaryRoot.userId().xform(strToQt); Q_EMIT userIdChanged(userId());
	LAGER_QT(token) = m_d->clientOnSecondaryRoot.token().xform(strToQt); Q_EMIT tokenChanged(token());
	LAGER_QT(deviceId) = m_d->clientOnSecondaryRoot.deviceId().xform(strToQt); Q_EMIT deviceIdChanged(deviceId());

	m_d->watchable.afterAll(
	[this](KazvEvent e) {
	Q_EMIT this->trigger(e);
	});

	m_d->watchable.after<LoginSuccessful>(
	[this](LoginSuccessful e) {
	Q_EMIT this->loginSuccessful(e);
	});

	m_d->watchable.after<LoginFailed>(
	[this](LoginFailed e) {
	Q_EMIT this->loginFailed(
	QString::fromStdString(e.errorCode),
	QString::fromStdString(e.error)
	);
	});

	m_d->watchable.after<ReceivingRoomTimelineEvent>(
	[this](ReceivingRoomTimelineEvent e) {
	Q_EMIT this->receivedMessage(
	QString::fromStdString(e.roomId),
	QString::fromStdString(e.event.id())
	);
	});

	connect(&m_d->saveTimer, &QTimer::timeout, &m_d->saveTimer, [m_d=m_d.get()]() {
	m_d->maybeSerialize();
	});
	const int saveIntervalMs = 1000 * 60 * 5;
	m_d->saveTimer.start(std::chrono::milliseconds{saveIntervalMs});
	}

	MatrixSdk::MatrixSdk(QObject *parent)
	: MatrixSdk(std::make_unique<MatrixSdkPrivate>(this, /* testing = */ false), parent)
	{
	}

	MatrixSdk::MatrixSdk(SdkModel model, bool testing, QObject *parent)
	: MatrixSdk(std::make_unique<MatrixSdkPrivate>(this, testing, std::move(model)), parent)
	{
	}

	static void cleanupDPointer(std::unique_ptr<MatrixSdkPrivate> oldD)
	{
	oldD->saveTimer.disconnect();
	oldD->saveTimer.stop();

	auto helper = new CleanupHelper(std::move(oldD));
	helper->cleanup();
	}

	MatrixSdk::~MatrixSdk()
	{
	if (m_d) {
	serializeToFile();
	cleanupDPointer(std::move(m_d));
	}
	}

	QString MatrixSdk::mxcUriToHttp(QString mxcUri) const
	{
	return QString::fromStdString(m_d->clientOnSecondaryRoot.mxcUriToHttp(mxcUri.toStdString()));
	}

	MatrixDeviceList *MatrixSdk::devicesOfUser(QString userId) const
	{
	return new MatrixDeviceList(m_d->clientOnSecondaryRoot.devicesOfUser(userId.toStdString()));
	}

	void MatrixSdk::login(const QString &userId, const QString &password)
	{
	m_d->clientOnSecondaryRoot
	.autoDiscover(userId.toStdString())
	.then([
	this,
	client=m_d->clientOnSecondaryRoot.toEventLoop(),
	userId,
	password
	](auto res) {
	if (!res.success()) {
	// FIXME use real error codes and msgs when available in libkazv
	Q_EMIT this->discoverFailed("", "");
	return res;
	}

	auto serverUrl = res.dataStr("homeserverUrl");

	client.passwordLogin(
	serverUrl,
	userId.toStdString(),
	password.toStdString(),
	"kazv 0.0.0"
	);

	return res;
	});
	m_d->runIoContext();
	}

	MatrixRoomList *MatrixSdk::roomList() const
	{
	return new MatrixRoomList(m_d->clientOnSecondaryRoot);
	}

	void MatrixSdk::emplace(std::optional<SdkModel> model)
	{
	auto testing = m_d->testing;

	if (m_d) {
	cleanupDPointer(std::move(m_d));
	}

	m_d = (model.has_value()
	? std::make_unique<MatrixSdkPrivate>(this, testing, std::move(model.value()))
	: std::make_unique<MatrixSdkPrivate>(this, testing));

	// Re-initialize lager-qt cursors and watchable connections
	init();

	m_d->runIoContext();

	m_d->clientOnSecondaryRoot.startSyncing();

	Q_EMIT sessionChanged();
	}

	QStringList MatrixSdk::allSessions() const
	{
	using StdPath = std::filesystem::path;
	auto userDataDir = StdPath(kazvUserDataDir().toStdString());
	auto allSessionsDir = userDataDir / "sessions";

	QStringList sessionNames;

	try {
	for (const auto &p : std::filesystem::directory_iterator(allSessionsDir)) {
	if (p.is_directory()) {
	auto userId = p.path().filename().native();
	for (const auto &q : std::filesystem::directory_iterator(p.path())) {
	auto path = q.path();
	auto deviceId = path.filename().native();
	std::error_code err;
	if (std::filesystem::exists(path / "store", err)) {
	sessionNames.append(QString::fromStdString(userId + "/" + deviceId));
	}
	}
	}
	}
	} catch (const std::filesystem::filesystem_error &) {
	qDebug() << "sessionDir not available, ignoring";
	}

	return sessionNames;
	}

	void MatrixSdk::serializeToFile() const
	{
	m_d->maybeSerialize();
	}

	bool MatrixSdk::loadSession(QString sessionName)
	{
	qDebug() << "in loadSession(), sessionName=" << sessionName;
	using StdPath = std::filesystem::path;
	auto userDataDir = StdPath(kazvUserDataDir().toStdString());
	auto sessionDir = userDataDir / "sessions" / sessionName.toStdString();

	auto storeFile = sessionDir / "store";

	auto metadataFile = sessionDir / "metadata";

	if (! std::filesystem::exists(storeFile)) {
	qDebug() << "storeFile does not exist, skip loading session " << sessionName;
	return false;
	}

	if (std::filesystem::exists(metadataFile)) {
	KConfig metadata(QString::fromStdString(metadataFile.native()));
	KConfigGroup mdGroup(&metadata, "Metadata");
	auto format = mdGroup.readEntry("archiveFormat");
	if (format != QStringLiteral("text")) {
	qDebug() << "Unknown archive format:" << format;
	return false;
	}
	auto version = mdGroup.readEntry("kazvVersion");
	auto curVersion = kazvVersionString();
	if (version != QString::fromStdString(curVersion)) {
	qDebug() << "A different version from the current one, making a backup";
	std::error_code err;
	auto now = std::chrono::system_clock::now();
	auto backupName =
	std::to_string(std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count());
	auto backupDir = sessionDir / "backup" / backupName;
	if (! std::filesystem::create_directories(backupDir, err)
	&& err) {
	qDebug() << "Cannot create backup directory";
	return false;
	}
	std::filesystem::copy_file(storeFile, backupDir / "store");
	std::filesystem::copy_file(metadataFile, backupDir / "metadata");
	}
	}

	SdkModel model;
	try {
	auto storeStream = std::ifstream(storeFile);
	if (! storeStream) {
	qDebug() << "Unable to open storeFile";
	return false;
	}
	using IAr = boost::archive::text_iarchive;
	auto archive = IAr{storeStream};
	archive >> model;
	qDebug() << "Finished loading session";
	} catch (const std::exception &e) {
	qDebug() << "Error when loading session:" << QString::fromStdString(e.what());
	return false;
	}
	emplace(std::move(model));
	return true;
	}

	bool MatrixSdk::startNewSession()
	{
	emplace(std::nullopt);
	return true;
	}

	static std::optional<std::string> optMaybe(QString s)
	{
	if (s.isEmpty()) {
	return std::nullopt;
	} else {
	return s.toStdString();
	}
	}

	void MatrixSdk::createRoom(
	bool isPrivate,
	const QString &name,
	const QString &alias,
	const QStringList &invite,
	bool isDirect,
	bool allowFederate,
	const QString &topic,
	const QJsonValue &powerLevelContentOverride
	)
	{
	m_d->clientOnSecondaryRoot.createRoom(
	isPrivate ? Kazv::RoomVisibility::Private : Kazv::RoomVisibility::Public,
	optMaybe(name),
	optMaybe(alias),
	qStringListToStdF(invite),
	isDirect,
	allowFederate,
	optMaybe(topic),
	nlohmann::json(powerLevelContentOverride)
	)
	.then([this, client=m_d->clientOnSecondaryRoot.toEventLoop()](auto stat) {
	if (stat.success()) {
	Q_EMIT createRoomSuccessful();
	} else {
	Q_EMIT createRoomFailed("", "");
	}
	});
	}

	MatrixPromise *MatrixSdk::joinRoom(const QString &idOrAlias, const QStringList &servers)
	{
	return new MatrixPromise(m_d->clientOnSecondaryRoot.joinRoom(
	idOrAlias.toStdString(),
	qStringListToStdF(servers)
	)
	.then([this, idOrAlias, client=m_d->clientOnSecondaryRoot.toEventLoop()](auto stat) {
	if (stat.success()) {
	Q_EMIT joinRoomSuccessful(idOrAlias);
	} else {
	Q_EMIT joinRoomFailed(idOrAlias, "", "");
	}
	}));
	}

	MatrixPromise *MatrixSdk::setDeviceTrustLevel(QString userId, QString deviceId, QString trustLevel)
	{
	return new MatrixPromise(
	m_d->clientOnSecondaryRoot.setDeviceTrustLevel(
	userId.toStdString(),
	deviceId.toStdString(),
	qStringToTrustLevelFunc(trustLevel)
	)
	);
	}

	MatrixPromise *MatrixSdk::getSelfProfile()
	{
	return new MatrixPromise(
	m_d->clientOnSecondaryRoot.getProfile(userId().toStdString())
	);
	}

	MatrixPromise *MatrixSdk::setDisplayName(QString displayName)
	{
	return new MatrixPromise(
	m_d->clientOnSecondaryRoot.setDisplayName(
	displayName.isEmpty() ? std::nullopt : std::optional<std::string>(displayName.toStdString())
	)
	);
	}

	MatrixPromise *MatrixSdk::setAvatarUrl(QString avatarUrl)
	{
	return new MatrixPromise(
	m_d->clientOnSecondaryRoot.setAvatarUrl(
	avatarUrl.isEmpty() ? std::nullopt : std::optional<std::string>(avatarUrl.toStdString())
	)
	);
	}

	void MatrixSdk::startThread()
	{
	m_d->runIoContext();
	}

	RandomInterface &MatrixSdk::randomGenerator() const
	{
	return m_d->randomGenerator;
	}

	+bool MatrixSdk::shouldNotify(MatrixEvent *event) const
	+{
	+ // Do not notify own event
	+ if (event->sender() == userId()) {
	+ return false;
	+ }
	+ return m_d->notificationHandler.handleNotification(event->underlyingEvent()).shouldNotify;
	+}
	+
	#include "matrix-sdk.moc"
	diff --git a/src/matrix-sdk.hpp b/src/matrix-sdk.hpp
	index 6229b1d..b74f708 100644
	--- a/src/matrix-sdk.hpp
	+++ b/src/matrix-sdk.hpp
	@@ -1,189 +1,198 @@
	/*
	* This file is part of kazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#pragma once
	#include <libkazv-config.hpp>
	#include <immer/config.hpp> // https://github.com/arximboldi/immer/issues/168

	#include <QObject>
	#include <QQmlEngine>
	#include <QString>

	#include <memory>

	#include <lager/extra/qt.hpp>

	#include <sdk-model.hpp>
	#include <random-generator.hpp>

	#include "meta-types.hpp"


	class MatrixRoomList;
	class MatrixDeviceList;
	class MatrixPromise;
	class MatrixSdkTest;
	+class MatrixEvent;

	struct MatrixSdkPrivate;

	class MatrixSdk : public QObject
	{
	Q_OBJECT
	QML_ELEMENT

	std::unique_ptr<MatrixSdkPrivate> m_d;

	/// @param d A dynamically allocated d-pointer, whose ownership
	/// will be transferred to this MatrixSdk.
	explicit MatrixSdk(std::unique_ptr<MatrixSdkPrivate> d, QObject *parent);

	void init();

	public:
	explicit MatrixSdk(QObject *parent = 0);
	~MatrixSdk() override;

	LAGER_QT_READER(QString, serverUrl);
	LAGER_QT_READER(QString, userId);
	LAGER_QT_READER(QString, token);
	LAGER_QT_READER(QString, deviceId);

	Q_INVOKABLE MatrixRoomList *roomList() const;

	Q_INVOKABLE QString mxcUriToHttp(QString mxcUri) const;

	Q_INVOKABLE MatrixDeviceList *devicesOfUser(QString userId) const;

	Kazv::RandomInterface &randomGenerator() const;

	private:
	// Replaces the store with another one
	void emplace(std::optional<Kazv::SdkModel> model);

	Q_SIGNALS:
	void trigger(Kazv::KazvEvent e);

	void loginSuccessful(Kazv::KazvEvent e);
	void loginFailed(QString errorCode, QString errorMsg);
	void discoverFailed(QString errorCode, QString errorMsg);

	void createRoomSuccessful();
	void createRoomFailed(QString errorCode, QString errorMsg);

	void joinRoomSuccessful(const QString &idOrAlias);
	void joinRoomFailed(const QString &idOrAlias, const QString &errorCode, const QString &errorMsg);

	void receivedMessage(QString roomId, QString eventId);

	void sessionChanged();

	public Q_SLOTS:
	void login(const QString &userId, const QString &password);

	/**
	* Serialize data to <AppDataDir>/sessions/<userid>/<deviceid>/
	*
	* If not logged in, do nothing.
	*/
	void serializeToFile() const;

	/**
	* Load session at <AppDataDir>/sessions/<sessionName> .
	*
	* @param sessionName A string in the form of <userid>/<deviceid> .
	*
	* @return true if successful, false otherwise.
	*/
	bool loadSession(QString sessionName);

	/**
	* Start an empty session.
	*
	* The new session is not logged in, and need to call login().
	*
	* @return true if successful, false otherwise.
	*/
	bool startNewSession();

	/**
	* Get all saved sessions.
	*
	* @return A list of session names in the form of <userid>/<deviceid> .
	*/
	QStringList allSessions() const;

	/**
	* Create a new room.
	*
	* @param isPrivate Whether the room is private.
	* @param name The room's name.
	* @param alias The alias of the room.
	* @param invite List of matrix ids of users to invite.
	* @param isDirect Whether it is a direct message room.
	* @param allowFederate Whether to allow users on other servers to join.
	* @param topic The topic of the room.
	* @param powerLevelContentOverride The content to override m.room.power_levels event.
	*/
	void createRoom(
	bool isPrivate,
	const QString &name,
	const QString &alias,
	const QStringList &invite,
	bool isDirect,
	bool allowFederate,
	const QString &topic,
	const QJsonValue &powerLevelContentOverride
	);

	/**
	* Join a room.
	* @param idOrAlias The id or alias of the room to join.
	* @param servers The servers to use when joining the room.
	*/
	MatrixPromise *joinRoom(
	const QString &idOrAlias,
	const QStringList &servers
	);

	/**
	* Change the trust level of a device.
	*
	* @param userId The user id that owns the device.
	* @param deviceId The device id to set the trust level.
	* @param trustLevel The trust level.
	*
	* @return A MatrixPromise representing the progress.
	*/
	MatrixPromise *setDeviceTrustLevel(QString userId, QString deviceId, QString trustLevel);

	/**
	* Get the profile of the current user.
	*
	* @return A MatrixPromise representing the progress.
	*/
	MatrixPromise *getSelfProfile();

	/**
	* Set the display name of the current user.
	*
	* @return A MatrixPromise representing the progress.
	*/
	MatrixPromise *setDisplayName(QString displayName);

	/**
	* Set the avatar url of the current user.
	*
	* @return A MatrixPromise representing the progress.
	*/
	MatrixPromise *setAvatarUrl(QString avatarUrl);

	+ /**
	+ * Check if an event should be notified.
	+ *
	+ * @param event The event to check.
	+ * @return Whether `event` should be notified.
	+ */
	+ bool shouldNotify(MatrixEvent *event) const;
	+
	private: // Testing
	friend MatrixSdkTest;
	friend MatrixSdk *makeTestSdk(Kazv::SdkModel model);

	explicit MatrixSdk(Kazv::SdkModel model, bool testing = false, QObject *parent = 0);
	void startThread();
	};

File Metadata

Mime Type: text/x-diff
Expires: Fri, Sep 18, 11:53 PM (55 m, 31 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768489
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions