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 // qui contient déjà les données nécessaires dans les paramètres de l'URL, // vous pouvez choisir d'utiliser cetteURL .            qDebug() << "Complete verification uri:" << completeVerificationUrl;
        } else { // Le serveur d'autorisation n'a fourni que l'URL de vérification ; utilisez-la.            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()

Construit un objet QOAuth2DeviceAuthorizationFlow.

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

Construit un objet QOAuth2DeviceAuthorizationFlow avec l'objet parent parent.

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

Construit 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()

Détruit l'instance QOAuth2DeviceAuthorizationFlow.

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

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

Si le serveur d'autorisation a fourni completeVerificationUrl, l'utilisateur peut naviguer vers cette URL. L'URL contient l'adresse userCode et tous les autres paramètres nécessaires.

Sinon, l'utilisateur doit se rendre à verificationUrl et entrer userCode manuellement.

Voir aussi Device Flow Usage.

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

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

Démarre le flux d'autorisation tel que décrit dans le RFC Device Grant.

Le flux se compose des étapes suivantes :

• Demande d'autorisation au serveur d'autorisation
• L'utilisateur autorise l'accès, voir authorizeWithUserCode()
• Interrogation du serveur d'autorisation jusqu'à ce que l'utilisateur ait accepté ou rejeté l'autorisation (ou que les codes expirent).
• Indication du résultat à l'application (voir granted() et QAbstractOAuth::requestFailed())

Le flux progresse automatiquement de l'autorisation à l'interrogation des jetons.

L'appel de cette fonction réinitialise toutes les données d'autorisation antérieures.

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 demande de rafraîchissement du jeton.

Si la demande de rafraîchissement a été initiée avec succès, le statut est mis à QAbstractOAuth::Status::RefreshingToken; sinon, le signal requestFailed() est émis et le statut n'est pas modifié. Les jetons ne peuvent pas être rafraîchis tant que isPolling est true.

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

Si le rafraîchissement du jeton échoue et qu'un jeton d'accès existe, le statut est fixé à QAbstractOAuth::Status::Granted, et à QAbstractOAuth::Status::NotAuthenticated s'il n'existe pas de jeton d'accès.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi QAbstractOAuth::requestFailed() et QAbstractOAuth2::refreshTokens().

[slot] bool QOAuth2DeviceAuthorizationFlow::startTokenPolling()

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

L'appel à 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 à grant(), l'interrogation est lancée automatiquement.

Cette fonction peut être utile dans les cas où il est nécessaire de reprendre (réessayer) l'interrogation des jetons un peu plus tard, sans redémarrer l'ensemble du flux d'autorisation. Par exemple, en cas de perte transitoire 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 demande d'interrogation est envoyée une fois que le premier intervalle s'est écoulé.

Voir aussi polling, stopTokenPolling(), et Device Flow Usage.

[slot] void QOAuth2DeviceAuthorizationFlow::stopTokenPolling()

Arrête l'interrogation des jetons. Toute demande d'interrogation potentielle en suspens est rejetée silencieusement.

Voir aussi polling et startTokenPolling().