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