bloccato in attesa di un segnale asincrono Qt

Question

lo so, ci sono alcune domande simili alle seguenti là fuori, ma non riuscivo a trovare una risposta concreta che mi aiuta. Quindi, ecco il mio problema:

Io lavoro su un'applicazione che fa alcuni gui-Inizializzazioni in fase di start up. Una delle cose che ho da fare, sta chiamando

NetworkConfigurationManager::updateConfigurations() 

Questa è una chiamata asincrona, che emette il segnale updateCompleted(), quando è finito. Il problema è che tutte le altre inizializzazioni della GUI devono attendere fino al termine dello updateConfigurations().

Quindi quello che ho potuto fare sarebbe qualcosa di simile:

MyApp::MyApp(QWidget *parent) : .... 
{ 
    doSomeInits(); 
    //Now connect the signal we have to wait for 
    connect(configManager, SIGNAL(updateCompleted()), this, SLOT(networkConfigurationUpdated())); 
    configManager->updateConfigurations(); //call the async function 
} 

void MyApp::networkConfigurationUpdated() 
{ 
    doSomething(); 
    doRemainingInitsThatHadToWaitForConfigMgr(); 
} 

di dividere l'inizializzazione non sembra un buon modo per me. Penso che renda il codice molto più difficile da leggere - le basi dovrebbero rimanere insieme. L'altra cosa è: Perché updateConfiguration() è asincrono, l'utente sarà in grado di utilizzare l'interfaccia grafica, che non gli è ancora dato alcuna informazione, perché siamo in attesa di updateCompleted().

Quindi c'è un modo per attendere il segnale updateCompleted(), prima che l'applicazione continui?

come:

MyApp::MyApp(QWidget *parent) : .... 
{ 
    doSomeInits(); 
    //Now connect the signal we have to wait for 
    connect(configManager, SIGNAL(updateCompleted()), this, SLOT(doSomething())); 
    ???? //wait until doSomething() is done. 
    doRemainingInitsThatHadToWaitForConfigMgr(); 
} 

In alcune API esistono alternative al blocco funzioni asincrone, ma non in questo caso.

Apprezzo qualsiasi aiuto. Grazie!

Answer 1

Il modo per farlo è quello di utilizzare i cicli di eventi nidificati. È sufficiente creare il proprio QEventLoop, collegare qualsiasi segnale che si desidera attendere allo slot del loop quit(), quindi il ciclo exec(). In questo modo, una volta che il segnale viene chiamato, attiverà lo slot quit() di QEventLoop, uscendo quindi dal ciclo exec().

MyApp::MyApp(QWidget *parent) : .... 
{ 
    doSomeInits(); 
    { 
     QEventLoop loop; 
     loop.connect(configManager, SIGNAL(updateCompleted()), SLOT(quit())); 
     configManager->updateConfigurations(); 
     loop.exec(); 
    } 
    doReaminingInitsThatHadToWaitForConfigMgr(); 
} 

Answer 2

Lavorare da chalup s' answer, se avete intenzione di essere in attesa per un tempo user-evidente, si potrebbe desiderare di mostrare un progress bar invece (o un splash screen, forse).

MyApp::MyApp(QWidget *parent) : .... 
{ 
    doSomeInits(); 
    { 
     QSpashScreen splash; 
     splash.connect(configManager, SIGNAL(updateCompleted()), SLOT(close())); 
     configManager->updateConfigurations(); 
     splash.exec(); 
    } 
    doReaminingInitsThatHadToWaitForConfigMgr(); 
} 

Answer 3

Un'altra soluzione potrebbe essere quella di utilizzare QSignalSpy::wait(). Questa funzione è stata introdotta in Qt 5 e fa esattamente ciò che desideri.

L'unico problema che vedo con quella classe è che viene fornito nel modulo QtTest. Nel mio caso lo trovo molto utile durante il test del codice, ma potrebbe non essere la soluzione migliore per il codice di produzione.