QSessionManager Class

Documentation sur les fonctions membres

bool QSessionManager::allowsErrorInteraction()

Renvoie ` true ` si l'interaction en cas d'erreur est autorisée ; sinon, renvoie ` false`.

Cette fonction est similaire à ` allowsInteraction()`, mais permet également à l'application d'informer l'utilisateur des erreurs qui surviennent. Les gestionnaires de session peuvent accorder une priorité plus élevée aux demandes d'interaction en cas d'erreur, ce qui signifie qu'une interaction est plus susceptible d'être autorisée. Cependant, il n'est pas garanti que le gestionnaire de session autorise l'interaction.

Voir également allowsInteraction(), release() et cancel().

bool QSessionManager::allowsInteraction()

Demande au gestionnaire de session l'autorisation d'interagir avec l'utilisateur. Renvoie « true » si l'interaction est autorisée ; sinon, renvoie « false ».

Ce mécanisme a pour but de permettre la synchronisation des interactions de l'utilisateur lors d'un arrêt du système. Les gestionnaires de session avancés peuvent demander à toutes les applications de valider leurs données simultanément, ce qui permet un arrêt beaucoup plus rapide.

Une fois l’interaction terminée, nous recommandons vivement de libérer le sémaphore d’interaction avec l’utilisateur en appelant la fonction ` release()`. Ainsi, d’autres applications pourront interagir avec l’utilisateur pendant que votre application est encore occupée à enregistrer des données. (Le sémaphore est implicitement libéré lorsque l’application se ferme.)

Si l’utilisateur décide d’annuler le processus d’arrêt pendant la phase d’interaction, vous devez signaler cet événement au gestionnaire de session en appelant la fonction ` cancel()`.

Voici un exemple d’implémentation de la fonction ` QGuiApplication::commitDataRequest()` d’une application :

MyMainWidget::MyMainWidget(QWidget*parent)
    : QWidget(parent)
{
    connect(qApp, &QGuiApplication::commitDataRequest,
           this, &MyMainWidget::commitData);
}

void MyMainWidget::commitData(QSessionManager& manager)
{
    if (manager.allowsInteraction()) {
        int ret = QMessageBox::warning(
                    mainWindow,
                    tr("Mon application"),
                    tr("Enregistrer les modifications dans le document ?"),
                    QMessageBox::Enregistrer | QMessageBox::Discard | QMessageBox::Annuler);

        switch (ret) {
        case QMessageBox::Save :
            manager.release();
            if (!saveDocument())
                manager.cancel();
            break;
        case QMessageBox::Ignorer :
            break;
        case QMessageBox::Annuler:
        par défaut:
            manager.cancel();
        }
    } else {
        // nous n'avons pas obtenu l'autorisation d'interagir, alors
        // faisons quelque chose de raisonnable à la place
    }
}

Si une erreur s'est produite au sein de l'application lors de l'enregistrement de ses données, vous pouvez essayer d'appeler allowsErrorInteraction() à la place.

Voir également QGuiApplication::commitDataRequest(), release() et cancel().

void QSessionManager::cancel()

Indique au gestionnaire de session d'annuler le processus d'arrêt. Les applications ne doivent pas appeler cette fonction sans avoir préalablement demandé l'accord de l'utilisateur.

Voir également allowsInteraction() et allowsErrorInteraction().

QStringList QSessionManager::discardCommand() const

Renvoie la commande de suppression actuellement définie.

Voir également setDiscardCommand(), restartCommand() et setRestartCommand().

bool QSessionManager::isPhase2() const

Renvoie « true » si le gestionnaire de sessions est actuellement en train d'exécuter une deuxième phase de gestion des sessions ; sinon, renvoie « false ».

Voir également requestPhase2().

void QSessionManager::release()

Libère le sémaphore d'interaction du gestionnaire de session à l'issue d'une phase d'interaction.

Voir également allowsInteraction() et allowsErrorInteraction().

void QSessionManager::requestPhase2()

Demande une deuxième phase de gestion de session pour l'application. L'application peut alors sortir immédiatement des fonctions ` QGuiApplication::commitDataRequest()` ou ` QApplication::saveStateRequest()`, qui seront à nouveau appelées une fois que la plupart ou la totalité des autres applications auront terminé leur gestion de session.

Ces deux phases sont utiles pour des applications telles que le gestionnaire de fenêtres X11, qui ont besoin de stocker des informations sur les fenêtres d'une autre application et doivent donc attendre que ces applications aient terminé leurs tâches respectives de gestion de session.

Voir également isPhase2().

QStringList QSessionManager::restartCommand() const

Renvoie la commande de redémarrage actuellement définie.

Voir également setRestartCommand() et restartHint().

QSessionManager::RestartHint QSessionManager::restartHint() const

Renvoie l'indication de redémarrage actuelle de l'application. La valeur par défaut est « RestartIfRunning ».

Voir également setRestartHint().

QString QSessionManager::sessionId() const

Renvoie l'identifiant de la session en cours.

Si l'application a été restaurée à partir d'une session antérieure, cet identifiant est le même que celui de la session antérieure.

Voir également sessionKey() et QGuiApplication::sessionId().

QString QSessionManager::sessionKey() const

Renvoie la clé de session de la session en cours.

Si l'application a été restaurée à partir d'une session antérieure, cette clé est la même que celle qui était en vigueur à la fin de la session précédente.

La clé de session change à chaque appel de la fonction `commitData()` ou `saveState()`.

Voir également sessionId() et QGuiApplication::sessionKey().

void QSessionManager::setDiscardCommand(const QStringList &command)

Définit la commande de suppression sur l'command indiquée.

Voir également discardCommand() et setRestartCommand().

void QSessionManager::setManagerProperty(const QString &name, const QStringList &value)

Les accès en écriture de bas niveau à l'enregistrement d'identification et d'état de l'application sont gérés par le gestionnaire de session.

La propriété intitulée « name » a pour valeur la liste de chaînes « value ».

void QSessionManager::setManagerProperty(const QString &name, const QString &value)

Les droits d'écriture de bas niveau sur les enregistrements d'identification et d'état de l'application sont gérés par le gestionnaire de sessions.

La propriété intitulée « name » a pour valeur la chaîne de caractères « value ».

void QSessionManager::setRestartCommand(const QStringList &command)

Si le gestionnaire de sessions est capable de restaurer des sessions, il exécutera la commande « command » afin de restaurer l'application. La commande utilise par défaut l'option

appname -session id

L’option ` -session ` est obligatoire ; sinon, ` QGuiApplication ` ne peut pas déterminer si l’application a été restaurée ni quel est l’identifiant de session actuel. Voir QGuiApplication::isSessionRestored() et QGuiApplication::sessionId() pour plus de détails.

Si votre application est très simple, il est parfois possible de stocker l’intégralité de l’état de l’application dans des options de ligne de commande supplémentaires. C’est généralement une très mauvaise idée, car les lignes de commande sont souvent limitées à quelques centaines d’octets. Utilisez plutôt QSettings, des fichiers temporaires ou une base de données à cette fin. En marquant les données avec l’identifiant unique sessionId(), vous pourrez restaurer l’application lors d’une session ultérieure.

Voir également restartCommand(), setDiscardCommand() et setRestartHint().

void QSessionManager::setRestartHint(QSessionManager::RestartHint hint)

Définit l'indicateur de redémarrage de l'application sur « hint ». Au démarrage de l'application, l'indicateur est défini sur « RestartIfRunning ».

Nous recommandons de définir l'indication de redémarrage dans ` QGuiApplication::saveStateRequest()` car la plupart des gestionnaires de session effectuent un point de contrôle peu après le démarrage d'une application.

Voir également ` restartHint()`.