service/polkit: use bindable properties

Author: Cu3PO42

src/services/polkit/agentimpl.cpp

@@ -36,12 +36,13 @@ PolkitAgentImpl::~PolkitAgentImpl() {
 		delete req;
 	}
 
-	if (this->activeFlow) {
-		this->activeFlow->cancelAuthenticationRequest();
-		this->activeFlow->deleteLater();
+	auto* flow = this->bActiveFlow.value();
+	if (flow) {
+		flow->cancelAuthenticationRequest();
+		flow->deleteLater();
 	}
 
-	if (this->isRegistered) qs_polkit_agent_unregister(this->listener.get());
+	if (this->bIsRegistered.value()) qs_polkit_agent_unregister(this->listener.get());
 }
 
 PolkitAgentImpl* PolkitAgentImpl::tryGetOrCreate(PolkitAgent* agent) {
@@ -70,7 +71,6 @@ PolkitAgentImpl* PolkitAgentImpl::tryTakeover(PolkitAgent* agent) {
 	}
 
 	instance->qmlAgent = agent;
-	emit agent->isRegisteredChanged();
 
 	return instance;
 }
@@ -82,13 +82,12 @@ void PolkitAgentImpl::onEndOfQmlAgent(PolkitAgent* agent) {
 	}
 }
 
+QBindable<AuthFlow*> PolkitAgentImpl::activeFlow() { return &this->bActiveFlow; }
+QBindable<bool> PolkitAgentImpl::isRegistered() { return &this->bIsRegistered; }
+
 void PolkitAgentImpl::registerComplete(bool success) {
-	if (success) {
-		this->isRegistered = true;
-		emit this->qmlAgent->isRegisteredChanged();
-	} else {
-		qCWarning(logPolkit) << "failed to register listener on path" << this->qmlAgent->path();
-	}
+	if (success) this->bIsRegistered = true;
+	else qCWarning(logPolkit) << "failed to register listener on path" << this->qmlAgent->path();
 }
 
 void PolkitAgentImpl::initiateAuthentication(AuthRequest* request) {
@@ -104,8 +103,9 @@ void PolkitAgentImpl::initiateAuthentication(AuthRequest* request) {
 void PolkitAgentImpl::cancelAuthentication(AuthRequest* request) {
 	qCDebug(logPolkit) << "cancelling authentication request from agent";
 
-	if (this->activeFlow && this->activeFlow->authRequest() == request) {
-		this->activeFlow->cancelFromAgent();
+	auto* flow = this->bActiveFlow.value();
+	if (flow && flow->authRequest() == request) {
+		flow->cancelFromAgent();
 	} else if (auto it = std::ranges::find(this->queuedRequests, request);
 	           it != this->queuedRequests.end())
 	{
@@ -139,11 +139,11 @@ void PolkitAgentImpl::activateAuthenticationRequest() {
 		return;
 	}
 
-	this->activeFlow = new AuthFlow(req, std::move(identities));
+	this->bActiveFlow = new AuthFlow(req, std::move(identities));
 
 	QObject::connect(
-	    this->activeFlow,
-	    &AuthFlow::completedChanged,
+	    this->bActiveFlow.value(),
+	    &AuthFlow::isCompletedChanged,
 	    this,
 	    &PolkitAgentImpl::finishAuthenticationRequest
 	);
@@ -154,19 +154,17 @@ void PolkitAgentImpl::activateAuthenticationRequest() {
 }
 
 void PolkitAgentImpl::finishAuthenticationRequest() {
-	if (!this->activeFlow) return;
+	if (!this->bActiveFlow.value()) return;
 
 	qCDebug(logPolkit) << "finishing authentication request for action"
-	                   << this->activeFlow->actionId();
+	                   << this->bActiveFlow.value()->actionId();
 
-	this->activeFlow->deleteLater();
-	this->activeFlow = nullptr;
-	emit this->qmlAgent->flowChanged();
+	this->bActiveFlow.value()->deleteLater();
 
 	if (!this->queuedRequests.empty()) {
 		this->activateAuthenticationRequest();
 	} else {
-		emit this->qmlAgent->isActiveChanged();
+		this->bActiveFlow = nullptr;
 	}
 }
 } // namespace qs::service::polkit

src/services/polkit/agentimpl.hpp

@@ -3,6 +3,7 @@
 #include <deque>
 
 #include <qobject.h>
+#include <qproperty.h>
 
 #include "flow.hpp"
 #include "gobjectref.hpp"
@@ -25,10 +26,17 @@ class PolkitAgentImpl
 	static PolkitAgentImpl* tryTakeover(PolkitAgent* agent);
 	static void onEndOfQmlAgent(PolkitAgent* agent);
 
+	[[nodiscard]] QBindable<AuthFlow*> activeFlow();
+	[[nodiscard]] QBindable<bool> isRegistered();
+
 	void initiateAuthentication(AuthRequest* request) override;
 	void cancelAuthentication(AuthRequest* request) override;
 	void registerComplete(bool success) override;
 
+signals:
+	void activeFlowChanged();
+	void isRegisteredChanged();
+
 private:
 	PolkitAgentImpl(PolkitAgent* agent);
 
@@ -40,13 +48,21 @@ class PolkitAgentImpl
 	void finishAuthenticationRequest();
 
 	GObjectRef<QsPolkitAgent> listener;
-	bool isRegistered = false;
-
 	PolkitAgent* qmlAgent = nullptr;
 
-	AuthFlow* activeFlow = nullptr;
 	std::deque<AuthRequest*> queuedRequests;
 
-	friend class PolkitAgent;
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    PolkitAgentImpl,
+	    AuthFlow*,
+	    bActiveFlow,
+	    &PolkitAgentImpl::activeFlowChanged
+	);
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    PolkitAgentImpl,
+	    bool,
+	    bIsRegistered,
+	    &PolkitAgentImpl::isRegisteredChanged
+	);
 };
 } // namespace qs::service::polkit

src/services/polkit/flow.cpp

@@ -21,10 +21,10 @@ AuthFlow::AuthFlow(AuthRequest* request, QList<Identity*>&& identities, QObject*
     : QObject(parent)
     , mRequest(request)
     , mIdentities(std::move(identities))
-    , mSelectedIdentity(this->mIdentities.isEmpty() ? nullptr : this->mIdentities.first()) {
+    , bSelectedIdentity(this->mIdentities.isEmpty() ? nullptr : this->mIdentities.first()) {
 	// We reject auth requests with no identities before a flow is created.
 	// This should never happen.
-	if (!this->mSelectedIdentity)
+	if (!this->bSelectedIdentity.value())
 		qCFatal(logPolkitState) << "AuthFlow created with no valid identities!";
 
 	for (auto* identity: this->mIdentities) {
@@ -42,38 +42,35 @@ const QString& AuthFlow::actionId() const { return this->mRequest->actionId; }
 const QString& AuthFlow::cookie() const { return this->mRequest->cookie; }
 const QList<Identity*>& AuthFlow::identities() const { return this->mIdentities; }
 
-Identity* AuthFlow::selectedIdentity() const { return this->mSelectedIdentity; }
+QBindable<Identity*> AuthFlow::selectedIdentity() { return &this->bSelectedIdentity; }
 
 void AuthFlow::setSelectedIdentity(Identity* identity) {
-	if (this->mSelectedIdentity == identity) return;
+	if (this->bSelectedIdentity.value() == identity) return;
 	if (!identity) {
 		qmlWarning(this) << "Cannot set selected identity to null.";
 		return;
 	}
-	for (auto* id: this->mIdentities) {
-		if (id == identity) {
-			this->mSelectedIdentity = id;
-			emit this->selectedIdentityChanged();
-			return;
-		}
-	}
+	this->bSelectedIdentity = identity;
+	this->currentSession->cancel();
+	this->setupSession();
 }
 
-bool AuthFlow::isResponseRequired() const { return this->mIsResponseRequired; }
-const QString& AuthFlow::inputPrompt() const { return this->mResponseMessage; }
-bool AuthFlow::responseVisible() const { return this->mResponseVisible; }
-const QString& AuthFlow::supplementaryMessage() const { return this->mExtraMessage; }
-bool AuthFlow::supplementaryIsError() const { return this->mExtraIsError; }
-bool AuthFlow::isCompleted() const { return this->mIsCompleted; }
-bool AuthFlow::isSuccessful() const { return this->mIsSuccessful; }
+QBindable<bool> AuthFlow::isResponseRequired() { return &this->bIsResponseRequired; }
+QBindable<QString> AuthFlow::inputPrompt() { return &this->bInputPrompt; }
+QBindable<bool> AuthFlow::responseVisible() { return &this->bResponseVisible; }
+QBindable<QString> AuthFlow::supplementaryMessage() { return &this->bSupplementaryMessage; }
+QBindable<bool> AuthFlow::supplementaryIsError() { return &this->bSupplementaryIsError; }
+QBindable<bool> AuthFlow::isCompleted() { return &this->bIsCompleted; }
+QBindable<bool> AuthFlow::isSuccessful() { return &this->bIsSuccessful; }
+QBindable<bool> AuthFlow::isCancelled() { return &this->bIsCancelled; }
 AuthRequest* AuthFlow::authRequest() const { return this->mRequest; }
 
 void AuthFlow::cancelFromAgent() {
 	if (!this->currentSession) return;
 
 	qCDebug(logPolkitState) << "cancelling authentication request from agent";
 
-	this->mIsCancelled = true;
+	this->bIsCancelled = true;
 	this->currentSession->cancel();
 
 	emit this->authenticationRequestCancelled();
@@ -88,18 +85,17 @@ void AuthFlow::submit(const QString& value) {
 
 	this->currentSession->respond(value);
 
-	this->mIsResponseRequired = false;
-	this->mResponseMessage.clear();
-	this->mResponseVisible = false;
-	emit this->responseRequestChanged();
+	this->bIsResponseRequired = false;
+	this->bInputPrompt = QString {};
+	this->bResponseVisible = false;
 }
 
 void AuthFlow::cancelAuthenticationRequest() {
 	if (!this->currentSession) return;
 
 	qCDebug(logPolkitState) << "cancelling authentication request by user request";
 
-	this->mIsCancelled = true;
+	this->bIsCancelled = true;
 	this->currentSession->cancel();
 
 	this->mRequest->cancel("Authentication request cancelled by user.");
@@ -108,10 +104,14 @@ void AuthFlow::cancelAuthenticationRequest() {
 void AuthFlow::setupSession() {
 	delete this->currentSession;
 
-	qCDebug(logPolkitState) << "setting up session for identity" << this->mSelectedIdentity->name();
+	qCDebug(logPolkitState) << "setting up session for identity"
+	                        << this->bSelectedIdentity.value()->name();
 
-	this->currentSession =
-	    new Session(this->mSelectedIdentity->polkitIdentity.get(), this->mRequest->cookie, this);
+	this->currentSession = new Session(
+	    this->bSelectedIdentity.value()->polkitIdentity.get(),
+	    this->mRequest->cookie,
+	    this
+	);
 	QObject::connect(this->currentSession, &Session::request, this, &AuthFlow::request);
 	QObject::connect(this->currentSession, &Session::completed, this, &AuthFlow::completed);
 	QObject::connect(this->currentSession, &Session::showError, this, &AuthFlow::showError);
@@ -120,39 +120,32 @@ void AuthFlow::setupSession() {
 }
 
 void AuthFlow::clearState() {
-	this->mIsResponseRequired = false;
-	this->mResponseMessage.clear();
-	this->mResponseVisible = false;
-	this->mExtraMessage.clear();
-	this->mExtraIsError = false;
-
-	emit this->responseRequestChanged();
-	emit this->supplementaryChanged();
+	this->bIsResponseRequired = false;
+	this->bInputPrompt = QString {};
+	this->bResponseVisible = false;
+	this->bSupplementaryMessage = QString {};
+	this->bSupplementaryIsError = false;
 }
 
 void AuthFlow::request(const QString& message, bool echo) {
-	this->mIsResponseRequired = true;
-	this->mResponseMessage = message;
-	this->mResponseVisible = echo;
-	emit this->responseRequestChanged();
+	this->bIsResponseRequired = true;
+	this->bInputPrompt = message;
+	this->bResponseVisible = echo;
 }
 
 void AuthFlow::completed(bool gainedAuthorization) {
 	qCDebug(logPolkitState) << "authentication session completed, gainedAuthorization ="
-	                        << gainedAuthorization << ", isCancelled =" << this->mIsCancelled;
+	                        << gainedAuthorization << ", isCancelled =" << this->bIsCancelled.value();
 
 	if (gainedAuthorization) {
-		this->mIsCompleted = true;
-		this->mIsSuccessful = true;
+		this->bIsCompleted = true;
+		this->bIsSuccessful = true;
 		this->mRequest->complete();
 
-		emit this->completedChanged();
 		emit this->authenticationSucceeded();
-	} else if (this->mIsCancelled) {
-		this->mIsCompleted = true;
-		this->mIsSuccessful = false;
-
-		emit this->completedChanged();
+	} else if (this->bIsCancelled.value()) {
+		this->bIsCompleted = true;
+		this->bIsSuccessful = false;
 	} else {
 		emit this->authenticationFailed();
 
@@ -162,14 +155,12 @@ void AuthFlow::completed(bool gainedAuthorization) {
 }
 
 void AuthFlow::showError(const QString& message) {
-	this->mExtraMessage = message;
-	this->mExtraIsError = true;
-	emit this->supplementaryChanged();
+	this->bSupplementaryMessage = message;
+	this->bSupplementaryIsError = true;
 }
 
 void AuthFlow::showInfo(const QString& message) {
-	this->mExtraMessage = message;
-	this->mExtraIsError = false;
-	emit this->supplementaryChanged();
+	this->bSupplementaryMessage = message;
+	this->bSupplementaryIsError = false;
 }
 } // namespace qs::service::polkit