QFTP keine Signale im release

[dacown]

hi,
mein Programm funktioniert einwandfrei im "Debug-Modus", jedoch im "Release-Modus", kommen keine Signale von QFTP.

Code: Alles auswählen

FTPManager::FTPManager(QObject *parent) : QObject(parent)
{
   ftp = new QFtp(this);
   m_iDownloadDateiGroesse=0;
   m_iUploadDateiGroesse=0;
   connect(ftp, SIGNAL(commandFinished(int,bool)),this, SLOT(ftpCommandFinished(int,bool)));
   connect(ftp, SIGNAL(dataTransferProgress(qint64,qint64)),this, SLOT(updateDataTransferProgress(qint64,qint64)));
   connect(ftp, SIGNAL(readyRead()),this,SLOT(readData()));
   connect(ftp, SIGNAL(listInfo(QUrlInfo)), this, SLOT(GetList(QUrlInfo)));
}

Keiner der Slots wird im "Release-Modus" aufgerufen.

Mir ist grad noch etwas aufgefallen, beim release bekomme ich folgende Meldung bei Ausgabe der Anwendung:

QObject: Cannot create children for a parent that is in a different thread.
(Parent is FTPManager(0xdfd849c), parent's thread is QThread(0xaf8018), current thread is QThread(0xe00cff8)

dieser Meldung kommt beim debug nicht.

[Christian81]

Läuft FtpManager in einem anderen Thread?

[dacown]

Eigendlich nicht, habe keine extra Threads im gesamten Programm bis jetzt.
Nur einen Timer, der aber nichts mit dieser Klasse zutun hat.

Code: Alles auswählen

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
 
    m_pRezepturVerwaltung = new RezepturVerwaltung(ui);
    m_pFTPManager = new FTPManager(this);

    connect(m_pFTPManager, SIGNAL(DownloadFinish()), m_pRezepturVerwaltung, SLOT(AktualisiereShowProgparOrdnerstruktur()));
    connect(m_pFTPManager, SIGNAL(OwndataTransferProgress(qint64,qint64)),m_pRezepturVerwaltung, SLOT(updateDataTransferProgress(qint64,qint64)));
    connect(m_pRezepturVerwaltung, SIGNAL(SignalUpload(QString, QString, QString, QString)),
            m_pFTPManager, SLOT(Upload(QString, QString, QString, QString)));
    connect(m_pRezepturVerwaltung, SIGNAL(SignalDownload(QString, QString, QString, QString)),
            m_pFTPManager, SLOT(Download(QString, QString, QString, QString)));

    //Alarmfenster kram
    m_pCAlarmListe = new AlarmListe(ui);
    m_SqlQuerryModelAlarm  = new QSqlQueryModel(this);
    m_dlgAlarmFenster = new dlgAlarmFenster(this);
    m_dlgAlarmFenster->setWindowModality(Qt::WindowModal);
    m_dlgAlarmFenster->setWindowFlags(Qt::Popup | Qt:: Dialog);

    QSqlDatabase *pDatenbank = g_CDatenbankVerwaltung.addDatenbank("jobpilot","jobpilot3");
    if(pDatenbank != NULL)
    {
        m_pAlarmTimer = new QTimer(this);
        m_pAlarmTimer->start(5000);
        connect(m_pAlarmTimer, SIGNAL(timeout()), this, SLOT(AlarmTimerSlot()));
    }

    connect(m_dlgAlarmFenster, SIGNAL(MaskenWechsel_Alarmliste()), this, SLOT(AlarmMaskenWechsel()));
    connect(m_pCAlarmListe, SIGNAL(WechselZuAktValues(int)), this, SLOT(on_WechselZuAktValues(int)));

}

Hab es auf das wichtigste zusammen gekürzt, dies sind alle klasse die etwas mit FTP zutun haben.
Der Thread Fehler ist mitlerweile nicht mehr vorhanden, hab ihn weg bekommen.

[dacown]

vl habe ich auch etwas falsch gemacht in der Klasse die mit QFTP arbeitet

Code: Alles auswählen

#include "ftpmanager.h"

FTPManager::FTPManager(QObject *parent)
{
   qDebug() << "erstellung 1";
   m_pFTP = new QFtp(parent->parent());

   qDebug() << "erstellung 2";
   m_iDownloadDateiGroesse=0;
   m_iUploadDateiGroesse=0;

   connect(m_pFTP, SIGNAL(commandFinished(int,bool)),this, SLOT(ftpCommandFinished(int,bool)));
   connect(m_pFTP, SIGNAL(dataTransferProgress(qint64,qint64)),this, SLOT(updateDataTransferProgress(qint64,qint64)));
   connect(m_pFTP, SIGNAL(readyRead()),this,SLOT(readData()));
   connect(m_pFTP, SIGNAL(listInfo(QUrlInfo)), this, SLOT(GetList(QUrlInfo)));

   qDebug() << "erstellung 3";
}

FTPManager::~FTPManager()
{
    qDebug() << "zerstörung";
}

void FTPManager::InitFtpConnection()
{
;
}

void FTPManager::connectToFtp(QString sServerIp)
{
    QString sDummyIp=sServerIp;
    int iDummy=sDummyIp.mid(0,3).toInt();
    sServerIp=QString::number(iDummy);

    iDummy=sDummyIp.mid(4,3).toInt();
    sServerIp=sServerIp + "." + QString::number(iDummy);

    iDummy=sDummyIp.mid(8,3).toInt();
    sServerIp=sServerIp + "." + QString::number(iDummy);

    iDummy=sDummyIp.mid(12,3).toInt();
    sServerIp=sServerIp + "." + QString::number(iDummy);

    int status = m_pFTP->connectToHost(sServerIp, 21);



    status=m_pFTP->login();

    qDebug() << "Connecting to FTP server " << sServerIp;

    status = m_pFTP->cd("StorageCard");

    m_pFTP->cd("DATA");
}

void FTPManager::downloadFile(QString sMaschinenListeNummer, QString sType, QString sName, QString sIP)
{
/*
    if(ftp->state() == QFtp::Unconnected)
    {
        connectToFtp(sIP);
    }
*/
    if(sType == "Tumbler")
    {
        QString fileName = "PROGPAR";
        QString fileEndung =".TAB";

        QString sOrdnerName = sType + "_" + sName;
        QString sPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\";
        QDir dir;
        dir.mkpath(sPfad);

        struktDownload DownloadFile;
        DownloadFile.sDateiendung = fileEndung;
        DownloadFile.sFileName = fileName;
        DownloadFile.sSpeicherPfad = sPfad;
        DownloadFile.sIP = sIP;

        m_lDownloadqueue.append(DownloadFile);
    }else if(sType == "Injektor")
    {
        QString fileName = "Programm";
        QString fileEndung =".TAB";

        QString sOrdnerName = sType + "_" + sName;
        QString sPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\";
        QDir dir;
        dir.mkpath(sPfad);

        struktDownload DownloadFile;
        DownloadFile.sDateiendung = fileEndung;
        DownloadFile.sFileName = fileName;
        DownloadFile.sSpeicherPfad = sPfad;
        DownloadFile.sIP = sIP;

        m_lDownloadqueue.append(DownloadFile);
    }else if(sType == "Lakemischer")
    {
        QString fileName = "PROGPAR";
        QString fileEndung =".TAB";

        QString sOrdnerName = sType + "_" + sName;
        QString sPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\";
        QDir dir;
        dir.mkpath(sPfad);

        struktDownload DownloadFile;
        DownloadFile.sDateiendung = fileEndung;
        DownloadFile.sFileName = fileName;
        DownloadFile.sSpeicherPfad = sPfad;
        DownloadFile.sIP = sIP;
        m_lDownloadqueue.append(DownloadFile);

        fileName = "ZUTATPAR";
        DownloadFile.sDateiendung = fileEndung;
        DownloadFile.sFileName = fileName;
        DownloadFile.sSpeicherPfad = sPfad;
        DownloadFile.sIP = sIP;
        m_lDownloadqueue.append(DownloadFile);
    }else if(sType == "Steaker")
    {
    }else
    {

    }

    downloadMehrereDateien();
/*
    actionFile = new QFile(sSpeicherPfad);
    while(actionFile->exists())
    {
        sSpeicherPfad =sPfad + fileName + QString::number(fileErweiterung) + fileEndung;
        actionFile->setFileName(sSpeicherPfad);
        fileErweiterung++;
    };

    if (!actionFile->open(QIODevice::WriteOnly))
    {
        qDebug() << "Datei kann nicht geöffnet werden";
        delete actionFile;
        return;
    }

    ftp->get(sDownlodFileName, actionFile);
    */
}

void FTPManager::downloadMehrereDateien()
{
    int error=0;

    if(m_lDownloadqueue.count() > 0)
    {
        int fileErweiterung = 1;
        QString sDateiUndSpeicherpfad = "", sDownlodFileName = "";
        struktDownload DownloadFile = m_lDownloadqueue.takeAt(0);


        if(m_pFTP->state() == QFtp::Unconnected)
        {
            connectToFtp(DownloadFile.sIP);
        }



        sDateiUndSpeicherpfad = DownloadFile.sSpeicherPfad + DownloadFile.sFileName + DownloadFile.sDateiendung;
        sDownlodFileName = DownloadFile.sFileName + DownloadFile.sDateiendung;

        actionFile = new QFile(sDateiUndSpeicherpfad);
        while( actionFile->exists() )
        {
            sDateiUndSpeicherpfad =DownloadFile.sSpeicherPfad + DownloadFile.sFileName + QString::number(fileErweiterung) + ".TAB";
            actionFile->setFileName(sDateiUndSpeicherpfad);
            fileErweiterung++;
        };


        if (!actionFile->open(QIODevice::WriteOnly))
        {
            qDebug() << "Datei kann nicht geöffnet werden";
            delete actionFile;
            downloadMehrereDateien();
        }else
        {
            m_sAktDownloadDateiName = DownloadFile.sFileName + DownloadFile.sDateiendung;
            m_pFTP->list();
            m_pFTP->get(sDownlodFileName, actionFile);
        }

    }else
    {
        m_pFTP->close();

    }
}



void FTPManager::UploadFile(QString sMaschinenType, QString sMaschinenName, QString sDateiName, QString sIP)
{
    QString sDateiErweiterung="",sOrdnerName="",sSpeicherPfad="", sDummy="";
    struktUpload dummyUploadStruk;

    if( sMaschinenType == "Tumbler" )
    {
        sDateiErweiterung = sDateiName;
        sDateiErweiterung.replace("PROGPAR","",Qt::CaseInsensitive);
        sDateiErweiterung.replace(".TAB","",Qt::CaseInsensitive);

        //ProgPar
        sOrdnerName = sMaschinenType + "_" + sMaschinenName;
        sSpeicherPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\" + sDateiName;

        dummyUploadStruk.sIP = sIP;
        dummyUploadStruk.sSpeicherPfadPlusDatei = sSpeicherPfad;
        dummyUploadStruk.sUploadZielName = "ProgPar.tab";
        m_lUploadqueue.append(dummyUploadStruk);

    }else if( sMaschinenType == "Lakemischer" )
    {
        sDateiErweiterung = sDateiName;
        sDateiErweiterung.replace("PROGPAR","",Qt::CaseInsensitive);
        sDateiErweiterung.replace(".TAB","",Qt::CaseInsensitive);

        //ProgPar
        sOrdnerName = sMaschinenType + "_" + sMaschinenName;
        sSpeicherPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\" + sDateiName;

        dummyUploadStruk.sIP = sIP;
        dummyUploadStruk.sSpeicherPfadPlusDatei = sSpeicherPfad;
        dummyUploadStruk.sUploadZielName = "ProgPar.tab";
        m_lUploadqueue.append(dummyUploadStruk);

        //ZutatPar
        sDateiName = "ZUTATPAR.TAB";
        sSpeicherPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\" + "ZUTATPAR" + sDateiErweiterung + ".TAB";;

        dummyUploadStruk.sIP = sIP;
        dummyUploadStruk.sSpeicherPfadPlusDatei = sSpeicherPfad;
        dummyUploadStruk.sUploadZielName = sDateiName;
        m_lUploadqueue.append(dummyUploadStruk);

    }else if( sMaschinenType == "Injektor" )
    {
        sDateiErweiterung = sDateiName;
        sDateiErweiterung.replace("Programm","",Qt::CaseInsensitive);
        sDateiErweiterung.replace(".TAB","",Qt::CaseInsensitive);


        //ProgPar
        sOrdnerName = sMaschinenType + "_" + sMaschinenName;
        sSpeicherPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\" + sDateiName;

        dummyUploadStruk.sIP = sIP;
        dummyUploadStruk.sSpeicherPfadPlusDatei = sSpeicherPfad;
        dummyUploadStruk.sUploadZielName = "Programm.tab";
        m_lUploadqueue.append(dummyUploadStruk);
    }else
    {
        sDateiErweiterung = sDateiName;
        sDateiErweiterung.replace("PROGPAR","",Qt::CaseInsensitive);
        sDateiErweiterung.replace(".TAB","",Qt::CaseInsensitive);

        //ProgPar
        sOrdnerName = sMaschinenType + "_" + sMaschinenName;
        sSpeicherPfad = g_CMaschinenVerwaltung.m_sRezeptDownloadPfad + "\\" + sOrdnerName + "\\" + sDateiName;

        dummyUploadStruk.sIP = sIP;
        dummyUploadStruk.sSpeicherPfadPlusDatei = sSpeicherPfad;
        dummyUploadStruk.sUploadZielName = "ProgPar.tab";
        m_lUploadqueue.append(dummyUploadStruk);
    }

    UploadMehrereDateien();
}

void FTPManager::UploadMehrereDateien()
{
    if(m_lUploadqueue.count() > 0)
    {
        struktUpload UploadFile = m_lUploadqueue.takeAt(0);

        if(m_pFTP->state() == QFtp::Unconnected)
        {
            connectToFtp(UploadFile.sIP);
        }

        actionFile = new QFile(UploadFile.sSpeicherPfadPlusDatei);//Ort wo die datei auf dem pc liegt
        m_iUploadDateiGroesse = actionFile->size();

        if(!actionFile->open(QIODevice::ReadWrite))
        {
            qDebug() << "Datei kann nicht geöffnet werden";
            delete actionFile;
            downloadMehrereDateien();
        }else
        {
            m_pFTP->setTransferMode(QFtp::Active);
            m_pFTP->put(actionFile, UploadFile.sUploadZielName);//sUploadFileName name die die datei auf der sps haben soll
        }

    }else
    {
        m_pFTP->close();

    }
}

void FTPManager::readData()
{
    QString dummy= QString(m_pFTP->readAll());
    qDebug() << "Read File Content-->" << dummy << "Read File END ";
}

void FTPManager::ftpCommandFinished(int id, bool error)
{
    qDebug() << "FTPManager::ftpCommandFinished";
    if (m_pFTP->currentCommand() == QFtp::ConnectToHost)
    {
        if (error)
        {
            QMessageBox msgBox;
            msgBox.setText(tr("Verbindungsfehler"));
            msgBox.setInformativeText(tr("Konnte keine Verbindung\n"
                                         "zu der Maschine herstellen"));
            msgBox.setStandardButtons(QMessageBox::Ok);
            msgBox.setDefaultButton(QMessageBox::No);
            msgBox.setIcon(QMessageBox::Warning);
            msgBox.exec();
            qDebug() << "konnte keine verbindung aufbauen";
            return;
        }
        qDebug() << "Verbindung aufgebaut";
        return;
    }

    if (m_pFTP->currentCommand() == QFtp::Login)
    {
        qDebug() << "Login";
    }

    if (m_pFTP->currentCommand() == QFtp::Get)
    {
        if (error)
        {
            qDebug() << "Download abgebrochen";
            actionFile->close();
            actionFile->remove();
            m_pFTP->close();

            delete actionFile;
            emit DownloadFinish();

        } else
        {
            qDebug() << "Wurd heruntergeladen";
            actionFile->close();
            emit DownloadFinish();
            delete actionFile;
            downloadMehrereDateien();
        }
    }

    if (m_pFTP->currentCommand() == QFtp::Put)
    {
        if (error)
        {
            qDebug() << "Upload abgebrochen";
            actionFile->close();
            actionFile->remove();
            m_pFTP->close();

            delete actionFile;
            emit UploadFinish();
        }else
        {
            qDebug() << "Wurd hochgeladen";
            actionFile->close();
            emit UploadFinish();
            delete actionFile;
            UploadMehrereDateien();
        }
    }
}

void FTPManager::updateDataTransferProgress(qint64 readBytes, qint64 totalBytes)
{
    qDebug() << "FTPManager::updateDataTransferProgress";
    if (m_pFTP->currentCommand() == QFtp::Get)
    {
        qDebug() << "Get updateDataTransferProgress";
        emit OwndataTransferProgress(readBytes,m_iDownloadDateiGroesse);
    }

    if (m_pFTP->currentCommand() == QFtp::Put)
    {
        qDebug() << "Put updateDataTransferProgress";
        emit OwndataTransferProgress(readBytes,m_iUploadDateiGroesse);
    }
}

void FTPManager::Upload(QString sMaschinenType, QString sMaschinenName, QString sDateiName, QString sIP)
{
    UploadFile(sMaschinenType, sMaschinenName, sDateiName, sIP);
}

void FTPManager::Download(QString sMaschinenListeNummer, QString sType, QString sName, QString sIP)
{
    downloadFile(sMaschinenListeNummer, sType, sName, sIP);
}

void FTPManager::GetList(const QUrlInfo &urlInfo)
{
    if(urlInfo.name().toUpper() == m_sAktDownloadDateiName)
    {
        m_iDownloadDateiGroesse = urlInfo.size();
    }
}

Oder kann es sein das ich als ich QFTP in mein QT integriert habe etwas schief gelaufen ist ?
Den ich benutze 5.6, ja ich weis mal soll eigendlich QNetworkAccessManager benutzen, jedoch war es damit nicht möglich von der SPS die Daten runter bzw. hochzuladen.

[Christian81]

Was ich so kurz sehe ist z.B. auch dass du QFtp::connectToHost ausführst und danach sofort QFtp::login(). Da connectToHost asynchron ist wird das login wohl sehr selten wirklich funktionieren da die Verbindung noch nicht aufgebaut ist. Das Selbe gilt für login() - ist auch asynchron.
Was soll diese komische QString / hostaddress in einen int und zurück bewirken?

[dacown]

Was ich so kurz sehe ist z.B. auch dass du QFtp::connectToHost ausführst und danach sofort QFtp::login(). Da connectToHost asynchron ist wird das login wohl sehr selten wirklich funktionieren da die Verbindung noch nicht aufgebaut ist. Das Selbe gilt für login() - ist auch asynchron.

Hat bis jetzt immer ohne Probleme funktioniert, aber du hast recht das werde ich noch abändern.
Jedoch dürfte das an meinem Problem nichts ändern.
Abgeänderte Version:

Code: Alles auswählen

void FTPManager::downloadMehrereDateien()
{
    //Überprüfen ob es noch Dateien zu abbarbeiten gibt
    if (!m_strukDownloadFile.xAktive)
    {
        if(m_lDownloadqueue.count() > 0)
        {
            m_strukDownloadFile = m_lDownloadqueue.takeAt(0);
            m_strukDownloadFile.xAktive = true;
        }else
        {
            m_pFTP->close();
            return;
        }
    }

    if(!m_struktStatus.Connected)
    {
        connectToFtp(m_strukDownloadFile.sIP);
    }else
    {
        if(!m_struktStatus.LoggedIn)
        {
            LoginToFtp();
        }else
        {
            m_pFTP->cd("StorageCard");

            m_pFTP->cd("DATA");

            int fileErweiterung = 1;
            QString sDateiUndSpeicherpfad = "", sDownlodFileName = "";


            sDateiUndSpeicherpfad = m_strukDownloadFile.sSpeicherPfad + m_strukDownloadFile.sFileName + m_strukDownloadFile.sDateiendung;
            sDownlodFileName = m_strukDownloadFile.sFileName + m_strukDownloadFile.sDateiendung;

            actionFile = new QFile(sDateiUndSpeicherpfad);
            while( actionFile->exists() )
            {
                sDateiUndSpeicherpfad =m_strukDownloadFile.sSpeicherPfad + m_strukDownloadFile.sFileName + QString::number(fileErweiterung) + ".TAB";
                actionFile->setFileName(sDateiUndSpeicherpfad);
                fileErweiterung++;
            };


            if (!actionFile->open(QIODevice::WriteOnly))
            {
                qDebug() << "Datei kann nicht geöffnet werden";
                delete actionFile;
                m_strukDownloadFile.xAktive = false; //ToDo: Später mehrere versuche dann erst false
                downloadMehrereDateien();
            }else
            {
                m_sAktDownloadDateiName = m_strukDownloadFile.sFileName + m_strukDownloadFile.sDateiendung;
                m_pFTP->list();
                m_pFTP->get(sDownlodFileName, actionFile);
                m_strukDownloadFile.xAktive = false;
                downloadMehrereDateien();
            }
        }
    }
}

Hat am Problem nichts geändert

Was soll diese komische QString / hostaddress in einen int und zurück bewirken?

Ich hab bei der IP Adressen Eingabe noch en kleines Problem, man muss da bis jetzt 010.002.234.011 eingeben.
und ich wandel es dann in 10.2.234.11 um.
Aber das ist erstmal ein unwichtiges Problem. Den das Programm is komplett lauffähig bis auf dieses Problem, welches ich oben beschrieben habe.

Du glaubst nicht das mir vl ein Fehler unterlaufen ist als ich QFTP zu QT hinzugefügt habe ?

In einem anderen Thread habe ich folgendes gelesen:

Your code looks good.
Try running "make clean" or "qmake". Your "ui_" or "moc_" files might need updating.

Hab darauf mal alles Bereinigen -> qmake ausführen -> alles Übersetzten gemacht, hat leider nichts geholfen.
Ebenfalls habe den gesamten Kompelierten Ordner gelöscht ebenfalls ohne erfolg.

[dacown]

Servus,
ich hab jetzt mal ein neues schmales Projekt erstellt.
In dem nur die Klasse, die Qftp verwendet drin ist.

Auch bei diesem Projekt, das selbe Problem, im Debug geht alles im Release nicht.

https://dl.dropboxusercontent.com/u/137 ... tptest.rar

[Christian81]

Woher weißt Du genau dass die Slots nicht aufgerufen werden? Nur an den Debug-Ausgaben? Ggf. werden die im Release-Modus gar nicht ausgeben - Stichwort QT_NO_DEBUG_OUTPUT

[Christian81]

Source:

Code: Alles auswählen

#include <QCoreApplication>
#include <QDebug>

#include "main.h"

Ftp::Ftp()
  : QObject()
  , m_curCommandId(0)
  , m_curCommand(0)
{
  connect(&m_ftp, SIGNAL(stateChanged(int)), this, SLOT(stateChanged(int)));
  connect(&m_ftp, SIGNAL(commandFinished(int,bool)), this, SLOT(commandFinished(int,bool)));
  connect(&m_ftp, SIGNAL(readyRead()), this, SLOT(readyRead()));
}

void Ftp::downloadFile(const QString &host, const QString &dir, const QString &file)
{
  m_host = host;
  m_dir = dir;
  m_file = file;
  m_curCommand = 0; // connect to host
  m_curCommandId = m_ftp.connectToHost(m_host);
}

void Ftp::stateChanged(int state)
{
  switch (state)
  {
  case QFtp::Unconnected:
    qWarning() << "Unconnected state - quit app";
    qApp->quit();
    break;
  case QFtp::HostLookup:
    qWarning() << "Looking up hostname";
    break;
  case QFtp::Connecting:
    qWarning() << "Connecting up host";
    break;
  case QFtp::Connected:
    qWarning() << "Connnected to host";
    break;
  case QFtp::LoggedIn:
    qWarning() << "Successfully logged in";
    break;
  case QFtp::Closing:
    qWarning() << "Closing connection";
    break;
  default:
    qWarning() << "Unknown state " << state;
    break;
  }
}

void Ftp::commandFinished(int id, bool error)
{
  if (id != m_curCommandId)
  {
    qWarning() << "Got command finished with unknown id " << id << " - error is " << (error ? "set" : "not set");
    return;
  }
  if (error)
  {
    qWarning() << "Error during command execution - command is " << m_curCommand;
    qWarning() << m_ftp.errorString();
    qApp->quit();
    return;
  }
  switch (m_curCommand)
  {
  case 0: // connect
    qWarning() << "Connected - logging in";
    m_curCommandId = m_ftp.login("anonymous");
    m_curCommand++;
    break;
  case 1: // login
    qWarning() << "Connected - changing directory";
    m_curCommandId = m_ftp.cd(m_dir);
    m_curCommand++;
    break;
  case 2: // cd
    qWarning() << "directory changed - retrieving file";
    m_curCommandId = m_ftp.get(m_file);
    m_curCommand++;
    break;
  case 3: // download
    qWarning() << "file retrieved - closing connection";
    m_curCommand++;
    m_curCommandId = m_ftp.close();
    break;
  case 4: // close
    qWarning() << "connection closed - quitting app";
    qApp->quit();
    break;
  default:
    qWarning() << "buuuh!";
    break;
  }
}

void Ftp::readyRead()
{
  qWarning() << "Incoming data!";
  qWarning() << m_ftp.readAll();
}


int main(int argc, char **argv)
{
  QCoreApplication app(argc, argv);

  int ret = 0;
  {
    Ftp ftp;
    ftp.downloadFile("ftp5.gwdg.de", "pub", "find.README");

    ret = app.exec();
  }
  return ret;
}

Header:

Code: Alles auswählen

#pragma once

#include <QBuffer>
#include <QFtp>
#include <QObject>

class Ftp : public QObject
{
  Q_OBJECT
public:
  Ftp();
  void downloadFile(const QString &host, const QString &dir, const QString &file);
private Q_SLOTS:
  void stateChanged(int state);
  void commandFinished(int id, bool error);
  void readyRead();
private:
  QString m_host;
  QString m_dir;
  QString m_file;
  QFtp m_ftp;
  int m_curCommandId;
  int m_curCommand;
};

Funktioniert bei mir problemlos.

[dacown]

Woher weißt Du genau dass die Slots nicht aufgerufen werden? Nur an den Debug-Ausgaben? Ggf. werden die im Release-Modus gar nicht ausgeben - Stichwort QT_NO_DEBUG_OUTPUT

Ja anhand der der Debug-Ausgaben, die anderen die nichts mit den Slots zutun haben werden ausgegeben.