QOAuth2DeviceAuthorizationFlow Class

m_deviceFlow.setAuthorizationUrl(QUrl(authorizationUrl));
m_deviceFlow.setTokenUrl(QUrl(accessTokenUrl));
m_deviceFlow.setRequestedScopeTokens({scope});
m_deviceFlow.setClientIdentifier(clientIdentifier);
// The need for a client secret depends on the authorization server
m_deviceFlow.setClientIdentifierSharedKey(clientSecret);

connect(&m_deviceFlow, &QOAuth2DeviceAuthorizationFlow::authorizeWithUserCode, this,
    [](const QUrl&verificationUrl, const QString&userCode, const QUrl&completeVerificationUrl) {
        if (completeVerificationUrl.isValid()) {
            // Si le serveur d'autorisation a fourni une URL complète
            // contenant déjà les données nécessaires dans les paramètres de l'URL,
            // vous pouvez choisir de l'utiliser
            qDebug() << "Complete verification uri:" << completeVerificationUrl;
        } else {
            // Le serveur d'autorisation n'a fourni qu'une URL de vérification ; utilisons celle-ci
            qDebug() << "Verification uri and usercode:" << verificationUrl << userCode;
        }
    }
);

connect(&m_deviceFlow, &QAbstractOAuth::requestFailed, this, [](QAbstractOAuth::Error error) {
    Q_UNUSED(error);
    // Handle error
});

connect(&m_deviceFlow, &QAbstractOAuth2::serverReportedErrorOccurred, this,
    [](const QString &error, const QString &errorDescription, const QUrl &uri) {
        // Check server reported error details if needed
        Q_UNUSED(error);
        Q_UNUSED(errorDescription);
        Q_UNUSED(uri);
    }
);

connect(&m_deviceFlow, &QAbstractOAuth::granted, this, [this](){
    // Here we use QNetworkRequestFactory to store the access token
    m_api.setBearerToken(m_deviceFlow.token().toLatin1());
});
m_deviceFlow.grant();

Documentation des fonctions membres

QOAuth2DeviceAuthorizationFlow::QOAuth2DeviceAuthorizationFlow()

Crée un objet QOAuth2DeviceAuthorizationFlow.

[explicit] QOAuth2DeviceAuthorizationFlow::QOAuth2DeviceAuthorizationFlow(QObject *parent)

Crée un objet `QOAuth2DeviceAuthorizationFlow` dont l'objet parent est ` parent`.

[explicit] QOAuth2DeviceAuthorizationFlow::QOAuth2DeviceAuthorizationFlow(QNetworkAccessManager *manager, QObject *parent = nullptr)

Crée un objet `QOAuth2DeviceAuthorizationFlow` en utilisant ` parent ` comme parent et définit ` manager ` comme gestionnaire d'accès au réseau.

[override virtual noexcept] QOAuth2DeviceAuthorizationFlow::~QOAuth2DeviceAuthorizationFlow()

Supprime l'instance de ` QOAuth2DeviceAuthorizationFlow `.

[signal] void QOAuth2DeviceAuthorizationFlow::authorizeWithUserCode(const QUrl &verificationUrl, const QString &userCode, const QUrl &completeVerificationUrl)

Ce signal est émis lorsque l'utilisateur doit finaliser l'autorisation.

Si le serveur d'autorisation a fourni l'URL completeVerificationUrl, l'utilisateur peut s'y rendre. Cette URL contient l'userCode nécessaire ainsi que tous les autres paramètres requis.

Sinon, l'utilisateur doit se rendre sur verificationUrl et saisir manuellement userCode.

Voir également Device Flow Usage.

[override virtual slot] void QOAuth2DeviceAuthorizationFlow::grant()

Réimplémente : QAbstractOAuth::grant().

Lance le flux d'autorisation tel que décrit dans le RFC « Device Grant ».

Le flux comprend les étapes suivantes :

• Demande d'autorisation adressée au serveur d'autorisation
• Autorisation de l'accès par l'utilisateur, voir authorizeWithUserCode()
• Interrogation du serveur d'autorisation jusqu'à ce que l'utilisateur ait accepté ou refusé l'autorisation (ou que les codes aient expiré)
• Communication du résultat à l'application (voir granted() et QAbstractOAuth::requestFailed())

Le flux passe automatiquement de l’autorisation à l’interrogation du jeton.

L'appel de cette fonction réinitialise toutes les données d'autorisation précédentes.

Voir également authorizeWithUserCode(), granted(), QAbstractOAuth::requestFailed(), polling, startTokenPolling(), stopTokenPolling() et Device Flow Usage.

[protected slot, since 6.9] void QOAuth2DeviceAuthorizationFlow::refreshTokensImplementation()

Cette fonction envoie une requête de rafraîchissement du jeton.

Si la demande de rafraîchissement a été lancée avec succès, l'état est défini sur « QAbstractOAuth::Status::RefreshingToken » ; dans le cas contraire, le signal « requestFailed()» est émis et l'état n'est pas modifié. Les jetons ne peuvent pas être rafraîchis tant que « isPolling » est défini sur « true ».

Cette fonction n'a aucun effet si le processus de rafraîchissement du jeton est déjà en cours.

Si l'actualisation du jeton échoue et qu'un jeton d'accès existe, l'état est défini sur QAbstractOAuth::Status::Granted, et sur QAbstractOAuth::Status::NotAuthenticated si aucun jeton d'accès n'existe.

Cette fonction a été introduite dans Qt 6.9.

Voir également QAbstractOAuth::requestFailed() et QAbstractOAuth2::refreshTokens().

[slot] bool QOAuth2DeviceAuthorizationFlow::startTokenPolling()

Lance l'interrogation des jetons. Renvoie true si le démarrage a réussi (ou si l'interrogation était déjà active), et false dans le cas contraire.

L'appel de cette fonction n'est pas nécessaire dans un cas d'utilisation typique. Une fois la demande d'autorisation terminée, à la suite de l'appel de grant(), l'interrogation est lancée automatiquement.

Cette fonction peut s’avérer utile dans les cas où il est nécessaire de reprendre (réessayer) l’interrogation du jeton un peu plus tard, sans redémarrer l’ensemble du flux d’autorisation. Par exemple, en cas de perte temporaire de connectivité réseau.

L’intervalle d’interrogation est défini par le serveur d’autorisation et est généralement de 5 secondes. La première requête d’interrogation est envoyée une fois ce premier intervalle écoulé.

Voir également polling, stopTokenPolling() et Device Flow Usage.

[slot] void QOAuth2DeviceAuthorizationFlow::stopTokenPolling()

Arrête l'interrogation des jetons. Toutes les requêtes d'interrogation éventuellement en attente sont ignorées sans message d'erreur.

Voir également polling et startTokenPolling().