Differential D29024 Diff 80695 backends/kwayland/waylandconfig.cpp

Changeset View

Standalone View

backends/kwayland/waylandconfig.cpp

1	/*************************************************************************************	1		/*************************************************************************
2	* Copyright 2014-2015 Sebastian Kügler <sebas@kde.org> *	2		Copyright © 2013 Martin Gräßlin <mgraesslin@kde.org>
3	* Copyright 2013 Martin Gräßlin <mgraesslin@kde.org> *	3		Copyright © 2014-2015 Sebastian Kügler <sebas@kde.org>
4	* *	4		Copyright © 2019-2020 Roman Gilg <subdiff@gmail.com>
5	* This library is free software; you can redistribute it and/or *	5
6	* modify it under the terms of the GNU Lesser General Public *	6		This library is free software; you can redistribute it and/or
7	* License as published by the Free Software Foundation; either *	7		modify it under the terms of the GNU Lesser General Public
8	* version 2.1 of the License, or (at your option) any later version. *	8		License as published by the Free Software Foundation; either
9	* *	9		version 2.1 of the License, or (at your option) any later version.
10	* This library is distributed in the hope that it will be useful, *	10
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	11		This library is distributed in the hope that it will be useful,
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *	12		but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* Lesser General Public License for more details. *	13		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* *	14		Lesser General Public License for more details.
15	* You should have received a copy of the GNU Lesser General Public *	15
16	* License along with this library; if not, write to the Free Software *	16		You should have received a copy of the GNU Lesser General Public
17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA *	17		License along with this library; if not, write to the Free Software
18	*************************************************************************************/	18		Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
		19		**************************************************************************/
19	#include "waylandconfig.h"	20		#include "waylandconfig.h"
20		21
21	#include "waylandbackend.h"	22		#include "waylandbackend.h"
		23		#include "wayland_interface.h"
22	#include "waylandoutput.h"	24		#include "waylandoutput.h"
23	#include "waylandscreen.h"	25		#include "waylandscreen.h"
24		26
25	#include "tabletmodemanager_interface.h"	27		#include "tabletmodemanager_interface.h"
		28		#include "wayland_logging.h"
26		29
27	#include <configmonitor.h>	30		#include <KPluginLoader>
28	#include <mode.h>	31		#include <KPluginMetaData>
29		32
30	#include <KWayland/Client/connection_thread.h>	33		namespace KScreen
31	#include <KWayland/Client/event_queue.h>	34		{
32	#include <KWayland/Client/registry.h>
33	#include <KWayland/Client/outputconfiguration.h>
34	#include <KWayland/Client/outputmanagement.h>
35
36	#include <QTimer>
37
38	using namespace KScreen;
39		35
40	WaylandConfig::WaylandConfig(QObject *parent)	36		WaylandConfig::WaylandConfig(QObject *parent)
41	: QObject(parent)	37		: QObject(parent)
42	, m_outputManagement(nullptr)
43	, m_registryInitialized(false)
44	, m_blockSignals(true)
45	, m_kscreenConfig(new Config)	38		, m_kscreenConfig(new Config)
46	, m_kscreenPendingConfig(nullptr)
47	, m_screen(new WaylandScreen(this))	39		, m_screen(new WaylandScreen(this))
48	, m_tabletModeAvailable(false)	40		, m_tabletModeAvailable(false)
49	, m_tabletModeEngaged(false)	41		, m_tabletModeEngaged(false)
50	{	42		{
51	initKWinTabletMode();	43		initKWinTabletMode();
52		44		queryInterfaces();
53	connect(this, &WaylandConfig::initialized, &m_syncLoop, &QEventLoop::quit);
54	QTimer::singleShot(3000, this, [this] {
55	if (m_syncLoop.isRunning()) {
56	qCWarning(KSCREEN_WAYLAND) << "Connection to Wayland server at socket:"
57	<< m_connection->socketName() << "timed out.";
58	m_syncLoop.quit();
59	m_thread->quit();
60	m_thread->wait();
61	}
62	});
63
64	initConnection();
65	m_syncLoop.exec();
66	}	45		}
67		46
68	WaylandConfig::~WaylandConfig()	47		WaylandConfig::~WaylandConfig()
69	{	48		{
70	m_thread->quit();	49		for (auto pending : m_pendingInterfaces) {
71	m_thread->wait();	50		rejectInterface(pending);
72	m_syncLoop.quit();	51		}
		52		m_pendingInterfaces.clear();
73	}	53		}
74		54
75	void WaylandConfig::initKWinTabletMode()	55		void WaylandConfig::initKWinTabletMode()
76	{	56		{
77	auto *interface = new OrgKdeKWinTabletModeManagerInterface(QStringLiteral("org.kde.KWin"),	57		auto *interface = new OrgKdeKWinTabletModeManagerInterface(QStringLiteral("org.kde.KWin"),
78	QStringLiteral("/org/kde/KWin"),	58		QStringLiteral("/org/kde/KWin"),
79	QDBusConnection::sessionBus(), this);	59		QDBusConnection::sessionBus(), this);
80	if (!interface->isValid()) {	60		if (!interface->isValid()) {
81	m_tabletModeAvailable = false;	61		m_tabletModeAvailable = false;
82	m_tabletModeEngaged = false;	62		m_tabletModeEngaged = false;
83	return;	63		return;
84	}	64		}
85		65
86	m_tabletModeAvailable = interface->tabletModeAvailable();	66		m_tabletModeAvailable = interface->tabletModeAvailable();
87	m_tabletModeEngaged = interface->tabletMode();	67		m_tabletModeEngaged = interface->tabletMode();
88		68
89	connect(interface, &OrgKdeKWinTabletModeManagerInterface::tabletModeChanged,	69		connect(interface, &OrgKdeKWinTabletModeManagerInterface::tabletModeChanged,
90	this, [this](bool tabletMode) {	70		this, [this](bool tabletMode) {
91	if (m_tabletModeEngaged == tabletMode) {	71		if (m_tabletModeEngaged == tabletMode) {
92	return;	72		return;
93	}	73		}
94	m_tabletModeEngaged = tabletMode;	74		m_tabletModeEngaged = tabletMode;
95	if (!m_blockSignals && m_initializingOutputs.empty()) {	75		if (m_interface && m_interface->isInitialized()) {
96	Q_EMIT configChanged();	76		Q_EMIT configChanged();
97	}	77		}
98	}	78		}
99	);	79		);
100	connect(interface, &OrgKdeKWinTabletModeManagerInterface::tabletModeAvailableChanged,	80		connect(interface, &OrgKdeKWinTabletModeManagerInterface::tabletModeAvailableChanged,
101	this, [this](bool available) {	81		this, [this](bool available) {
102	if (m_tabletModeAvailable == available) {	82		if (m_tabletModeAvailable == available) {
103	return;	83		return;
104	}	84		}
105	m_tabletModeAvailable = available;	85		m_tabletModeAvailable = available;
106	if (!m_blockSignals && m_initializingOutputs.empty()) {	86		if (m_interface && m_interface->isInitialized()) {
107	Q_EMIT configChanged();	87		Q_EMIT configChanged();
108	}	88		}
109	});	89		});
110	}	90		}
111		91
112	void WaylandConfig::initConnection()	92		bool WaylandConfig::isInitialized() const
113	{	93		{
114	m_thread = new QThread(this);	94		return m_interface && m_interface->isInitialized();
115	m_connection = new KWayland::Client::ConnectionThread;	95		}
116
117	connect(m_connection, &KWayland::Client::ConnectionThread::connected,
118	this, &WaylandConfig::setupRegistry, Qt::QueuedConnection);
119		96
120	connect(m_connection, &KWayland::Client::ConnectionThread::connectionDied,	97		ConfigPtr WaylandConfig::currentConfig()
121	this, &WaylandConfig::disconnected, Qt::QueuedConnection);	98		{
		99		// TODO: do this setScreen call less clunky
		100		m_kscreenConfig->setScreen(m_screen->toKScreenScreen(m_kscreenConfig));
122		101
123	connect(m_connection, &KWayland::Client::ConnectionThread::failed, this, [this] {	102		m_interface->updateConfig(m_kscreenConfig);
124	qCWarning(KSCREEN_WAYLAND) << "Failed to connect to Wayland server at socket:"
125	<< m_connection->socketName();
126	m_syncLoop.quit();
127	m_thread->quit();
128	m_thread->wait();
129	});
130		103
131	m_thread->start();	104		ScreenPtr screen = m_kscreenConfig->screen();
132	m_connection->moveToThread(m_thread);	105		m_screen->updateKScreenScreen(screen);
133	m_connection->initConnection();
134		106
		107		return m_kscreenConfig;
135	}	108		}
136		109
137	void WaylandConfig::blockSignals()	110		void WaylandConfig::setScreenOutputs()
138	{	111		{
139	Q_ASSERT(m_blockSignals == false);	112		m_screen->setOutputs(outputMap().values());
140	m_blockSignals = true;
141	}	113		}
142		114
143	void WaylandConfig::unblockSignals()	115		QMap<int, WaylandOutput*> WaylandConfig::outputMap() const
144	{	116		{
145	Q_ASSERT(m_blockSignals == true);	117		return m_interface->outputMap();
146	m_blockSignals = false;
147	}	118		}
148		119
149	void WaylandConfig::disconnected()	120		void WaylandConfig::applyConfig(const ConfigPtr &newConfig)
150	{	121		{
151	qCWarning(KSCREEN_WAYLAND) << "Wayland disconnected, cleaning up.";	122		m_interface->applyConfig(newConfig);
152	qDeleteAll(m_outputMap);
153	m_outputMap.clear();
154
155	// Clean up
156	if (m_queue) {
157	delete m_queue;
158	m_queue = nullptr;
159	}	123		}
160		124
161	m_connection->deleteLater();	125		void WaylandConfig::queryInterfaces()
162	m_connection = nullptr;	126		{
163		127		QTimer::singleShot(3000, this, [this] {
164	if (m_thread) {	128		for (auto pending : m_pendingInterfaces) {
165	m_thread->quit();	129		qCWarning(KSCREEN_WAYLAND) << pending.name << "backend could not be aquired in time.";
166	if (!m_thread->wait(3000)) {	130		rejectInterface(pending);
167	m_thread->terminate();
168	m_thread->wait();
169	}
170	delete m_thread;
171	m_thread = nullptr;
172	}	131		}
173		132		if (m_syncLoop.isRunning()) {
174	Q_EMIT configChanged();	133		qCWarning(KSCREEN_WAYLAND) << "Connection to Wayland server timed out. Does the "
		134		"compositor support output management?";
		135		m_syncLoop.quit();
175	}	136		}
		137		m_pendingInterfaces.clear();
		138		});
176		139
177	void WaylandConfig::setupRegistry()	140		auto availableInterfacePlugins
178	{	141		= KPluginLoader::findPlugins(QStringLiteral("org.kde.libkscreen.backends/wayland"));
179	m_queue = new KWayland::Client::EventQueue(this);
180	m_queue->setup(m_connection);
181
182	m_registry = new KWayland::Client::Registry(this);
183
184	connect(m_registry, &KWayland::Client::Registry::outputDeviceAnnounced,
185	this, &WaylandConfig::addOutput);
186
187	connect(m_registry, &KWayland::Client::Registry::outputManagementAnnounced,
188	this, [this](quint32 name, quint32 version) {
189	m_outputManagement = m_registry->createOutputManagement(name, version, m_registry);
190	checkInitialized();
191	}
192	);
193		142
194	connect(m_registry, &KWayland::Client::Registry::interfacesAnnounced,	143		for (auto plugin : availableInterfacePlugins) {
195	this, [this] {	144		queryInterface(&plugin);
196	m_registryInitialized = true;
197	unblockSignals();
198	checkInitialized();
199	}	145		}
200	);	146		m_syncLoop.exec();
201
202	m_registry->create(m_connection);
203	m_registry->setEventQueue(m_queue);
204	m_registry->setup();
205	}	147		}
206		148
207	int s_outputId = 0;	149		void WaylandConfig::queryInterface(KPluginMetaData *plugin)
208
209	void WaylandConfig::addOutput(quint32 name, quint32 version)
210	{	150		{
211	WaylandOutput *waylandoutput = new WaylandOutput(++s_outputId, this);	151		PendingInterface pending;
212	m_initializingOutputs << waylandoutput;
213
214	connect(waylandoutput, &WaylandOutput::deviceRemoved, this, [this, waylandoutput]() {
215	removeOutput(waylandoutput);
216	});
217	waylandoutput->createOutputDevice(m_registry, name, version);
218		152
219	// finalize: when the output is done, we put it in the known outputs map,	153		pending.name = plugin->name();
220	// remove if from the list of initializing outputs, and emit configChanged()
221	connect(waylandoutput, &WaylandOutput::complete, this, [this, waylandoutput]{
222	m_outputMap.insert(waylandoutput->id(), waylandoutput);
223	m_initializingOutputs.removeOne(waylandoutput);
224	checkInitialized();
225		154
226	if (!m_blockSignals && m_initializingOutputs.empty()) {	155		// TODO: qobject_cast not working here. Why?
			romanggAuthorUnsubmitted Not Done Someone having an idea about that? In general the plugin system is kinda funky. The thing returned is a singleton and gets returned whenever instantiate is called (that's why there is a factory to then generate objects on the heap). romangg: Someone having an idea about that? In general the plugin system is kinda funky. The thing…
227	m_screen->setOutputs(m_outputMap.values());	156		auto factory = dynamic_cast<WaylandFactory>(plugin->instantiate());
228	Q_EMIT configChanged();	157		if (!factory) {
		158		return;
229	}	159		}
		160		pending.interface = factory->createInterface(this);
		161		pending.thread = new QThread(this);
230		162
231	connect(waylandoutput, &WaylandOutput::changed, this, [this]() {	163		m_pendingInterfaces.push_back(pending);
232	if (!m_blockSignals) {	164		connect(pending.interface, &WaylandInterface::connectionFailed, this, [this, &pending] {
233	Q_EMIT configChanged();	165		qCWarning(KSCREEN_WAYLAND) << "Backend" << pending.name << "failed.";
234	}	166		rejectInterface(pending);
235	});	167		m_pendingInterfaces.erase(std::remove(m_pendingInterfaces.begin(),
		168		m_pendingInterfaces.end(), pending),
		169		m_pendingInterfaces.end());
236	});	170		});
237	}
238		171
239	void WaylandConfig::removeOutput(WaylandOutput *output)	172		connect(pending.interface, &WaylandInterface::initialized, this, [this, pending] {
240	{	173		if (m_interface) {
241	if (m_initializingOutputs.removeOne(output)) {	174		// Too late. Already have an interface initialized.
242	// output was not yet fully initialized, just remove here and return
243	delete output;
244	return;	175		return;
245	}	176		}
246		177
247	// remove the output from output mapping	178		for (auto other : m_pendingInterfaces) {
248	const auto removedOutput = m_outputMap.take(output->id());	179		if (other.interface != pending.interface) {
249	Q_ASSERT(removedOutput == output); Q_UNUSED(removedOutput);	180		rejectInterface(other);
250	m_screen->setOutputs(m_outputMap.values());
251	delete output;
252
253	if (!m_blockSignals) {
254	Q_EMIT configChanged();
255	}	181		}
256	}	182		}
		183		m_pendingInterfaces.clear();
257		184
258	bool WaylandConfig::isInitialized() const	185		takeInterface(pending);
259	{	186		m_syncLoop.quit();
260	return !m_blockSignals	187		});
261	&& m_registryInitialized
262	&& m_initializingOutputs.isEmpty()
263	&& m_outputMap.count() > 0
264	&& m_outputManagement != nullptr;
265	}
266		188
267	void WaylandConfig::checkInitialized()	189		pending.interface->initConnection(pending.thread);
268	{
269	if (isInitialized()) {
270	m_screen->setOutputs(m_outputMap.values());
271	Q_EMIT initialized();
272	}
273	}	190		}
274		191
275	KScreen::ConfigPtr WaylandConfig::currentConfig()	192		void WaylandConfig::takeInterface(const PendingInterface &pending)
276	{	193		{
277	// TODO: do this setScreen call less clunky	194		m_interface = pending.interface;
278	m_kscreenConfig->setScreen(m_screen->toKScreenScreen(m_kscreenConfig));	195		connect(m_interface, &WaylandInterface::configChanged, this, &WaylandConfig::configChanged);
279
280	const auto features = Config::Feature::Writable \| Config::Feature::PerOutputScaling
281	\| Config::Feature::AutoRotation \| Config::Feature::TabletMode;
282	m_kscreenConfig->setSupportedFeatures(features);
283	m_kscreenConfig->setValid(m_connection->display());
284
285	KScreen::ScreenPtr screen = m_kscreenConfig->screen();
286	m_screen->updateKScreenScreen(screen);
287
288	//Removing removed outputs
289	const KScreen::OutputList outputs = m_kscreenConfig->outputs();
290	for (const auto &output : outputs) {
291	if (!m_outputMap.contains(output->id())) {
292	m_kscreenConfig->removeOutput(output->id());
293	}
294	}
295
296	// Add KScreen::Outputs that aren't in the list yet, handle primaryOutput
297	KScreen::OutputList kscreenOutputs = m_kscreenConfig->outputs();
298	for (const auto &output : m_outputMap) {
299	KScreen::OutputPtr kscreenOutput = kscreenOutputs[output->id()];
300	if (!kscreenOutput) {
301	kscreenOutput = output->toKScreenOutput();
302	kscreenOutputs.insert(kscreenOutput->id(), kscreenOutput);
303	}
304	if (kscreenOutput && m_outputMap.count() == 1) {
305	kscreenOutput->setPrimary(true);
306	} else if (m_outputMap.count() > 1) {
307	// primaryScreen concept doesn't exist in kwayland, so we don't set one
308	}
309	output->updateKScreenOutput(kscreenOutput);
310	}
311	m_kscreenConfig->setOutputs(kscreenOutputs);
312
313	m_kscreenConfig->setTabletModeAvailable(m_tabletModeAvailable);
314	m_kscreenConfig->setTabletModeEngaged(m_tabletModeEngaged);
315
316	return m_kscreenConfig;
317	}
318		196
319	QMap<int, WaylandOutput*> WaylandConfig::outputMap() const	197		setScreenOutputs();
320	{	198		connect(m_interface, &WaylandInterface::outputsChanged, this, &WaylandConfig::setScreenOutputs);
321	return m_outputMap;
322	}
323		199
324	void WaylandConfig::tryPendingConfig()	200		qCDebug(KSCREEN_WAYLAND) << "Backend" << pending.name << "initialized.";
325	{	201		Q_EMIT initialized();
326	if (!m_kscreenPendingConfig) {
327	return;
328	}
329	applyConfig(m_kscreenPendingConfig);
330	m_kscreenPendingConfig = nullptr;
331	}	202		}
332		203
333	void WaylandConfig::applyConfig(const KScreen::ConfigPtr &newConfig)	204		void WaylandConfig::rejectInterface(const PendingInterface &pending)
334	{	205		{
335	using namespace KWayland::Client;	206		pending.thread->quit();
336	// Create a new configuration object	207		pending.thread->wait();
337	auto wlConfig = m_outputManagement->createConfiguration();	208		delete pending.thread;
338	bool changed = false;	209		delete pending.interface;
339
340	if (m_blockSignals) {
341	/* Last apply still pending, remember new changes and apply afterwards */
342	m_kscreenPendingConfig = newConfig;
343	return;
344	}
345
346	for (const auto &output : newConfig->outputs()) {
347	changed \|= m_outputMap[output->id()]->setWlConfig(wlConfig, output);
348	}
349		210
350	if (!changed) {	211		qCDebug(KSCREEN_WAYLAND) << "Backend" << pending.name << "rejected.";
351	return;
352	}	212		}
353		213
354	// We now block changes in order to compress events while the compositor is doing its thing
355	// once it's done or failed, we'll trigger configChanged() only once, and not per individual
356	// property change.
357	connect(wlConfig, &OutputConfiguration::applied, this, [this, wlConfig] {
358	wlConfig->deleteLater();
359	unblockSignals();
360	Q_EMIT configChanged();
361	tryPendingConfig();
362	});
363	connect(wlConfig, &OutputConfiguration::failed, this, [this, wlConfig] {
364	wlConfig->deleteLater();
365	unblockSignals();
366	Q_EMIT configChanged();
367	tryPendingConfig();
368	});
369
370	// Now block signals and ask the compositor to apply the changes.
371	blockSignals();
372	wlConfig->apply();
373	}	214		}