en attente d'un signal

Je suis en train de travailler sur une application qui charge le contenu du fichier vers le serveur.

Pour télécharger le fichier sur le serveur, je suis en utilisant ‘QNetworkAccessManager’ classe. Depuis, il travaille comme asynchrone, je l'ai changé de travail synchrone en utilisant QEventLoop.

Class FileTransfer
{
Public : 
     QNetworkAccessManager mNetworkManager;
     Void Upload(QNetworkRequest request, QIODevice *data)
     {
           responce = mNetworkManager.put(request, data);
           EventLoop.exec();
           ReadResponce(responce);
      }

      Void Stop()
      {
            responce ->close();
      }
}

Dans mon exemple d'application, j'ai 2 windows. 1er pour sélectionner les fichiers et la 2ème pour montrer le progrès.

Lorsque l'utilisateur clic sur le bouton télécharger dans la première fenêtre, la 2ème fenêtre s'affiche et puis j'ai créer le FileTransfer objet et démarrer le téléchargement.

En téléchargeant le fichier si l'utilisateur ferme le formulaire puis dans le destructeur de la fenêtre j'appelle à l'arrêt de l' ‘FileTransfer "après que j'ai supprimer le" FileTransfer’ objet.

Mais ici, le Upload() fonction n'est pas encore terminé, donc il va se planter.

S'il vous plaît aidez-moi à:
Comment attendre dans " stop () fonction jusqu'à ce que l'Upload() la fonction est terminée

OriginalL'auteur Umesha MS | 2010-06-16

qt qt-signals signals signals-slots

19

De ce que je peux voir à partir de votre code, vous êtes à l'exécution d'une QEventLoop mais vous n'êtes pas en train de connecter sa "quitter" logement pour tous les signaux. Prendre le ci-dessous à titre d'exemple, la connexion est un QHttp - et le code est pris à partir de quelque chose de différent, mais le principe s'applique.
```
/* Create the QEventLoop */
QEventLoop pause;
/* connect the QHttp.requestFinished() Signal to the QEventLoop.quit() Slot */
connect(&login, SIGNAL(requestFinished( int, bool )), &pause, SLOT(quit()));
/* The code that will run during the QEventLoop */
login.request(header,&logmein,&result);
/* Execute the QEventLoop - it will quit when the above finished due to the connect() */
pause.exec();
```
Il pourrait être appliqué à votre code, si je ne me trompe pas, c'est comme ça...
```
/* connect the signal to the relevant slot */
connect(&mNetworkManager, SIGNAL(finished( QNetworkReply )), &EventLoop, SLOT(quit()));
/* Execute the code that will run during QEventLoop */
responce = mNetworkManager.put(request, data);
/* Execute the QEventLoop */
EventLoop.exec();
```
Excuses si je me suis trompé à votre requête! Je suis le seul à se familiariser avec qt à nouveau après une rupture, mais je crois que c'est ce que tu veux dire! Bonne chance!

oui, j'ai ajouté le code pour sortir de la boucle d'événement dès que nous aurons fini de fente. mais le problème est que lors du téléchargement du fichier si l'utilisateur interrompt la connexion et supprimer l'objet. mais la fonction de téléchargement n'est pas encore terminée. à ce moment, il va se planter.

OriginalL'auteur EnOpenUK

Je pense que vous avez besoin d'ajouter quelque chose comme ça dans votre fonction de téléchargement:

if (upf->openFile())
{
    reply = manager->post(request, upf);
    connect(reply, SIGNAL(uploadProgress(qint64,qint64)), this, SIGNAL(progress(qint64,qint64)));
    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
    isInProgress = true;
    emit started();
} else
{
    emit finished(true, false, tr("Error: can't open file %1").arg(filename));
}

Voici le texte intégral du code: datacod-qt-outils

Espère que ça aide.

OriginalL'auteur mosg

0

Personnellement, je vous recommande de ne pas utiliser l'une de ces réponses.
Il suffirait de se connecter à un compte à rebours de verrouillage pour le signal.

De sorte que vous pourriez écrire:
```
Latch latch( 1 );
QObject::connect( reply, SIGNAL(finished()),
                  &latch, SLOT(countDown()) );

latch.wait();
```
Pour cela, vous auriez besoin d'un wrapper:
```
class Latch : public QObject {
    Q_OBJECT
public:
    Latch( uint count );
    void wait();
public slots:
    void countDown();
private:
    gcl::countdown_latch _latch;
};
```
J'ai peut-être tort, mais je ne pense pas que ce travail parce que le gcl compte à rebours loquet est destiné à bloquer un thread. Le put() appel qui se passe dans l'interface graphique principale fil, puis QNetworkAccessManager extrait de la page web dans un thread séparé, et le fini() logement est exécuté dans le main thread GUI. Donc, en utilisant ce code avec l'exemple serait juste cause la totalité de l'app pour le verrouiller en place. Il serait possible de déplacer le fini fente dans un thread différent, mais cela nécessiterait beaucoup plus de code qui n'est pas montré ici.

OriginalL'auteur abergmeier

Vous devez vous connecter pour publier un commentaire.