From 4fc80fd366c0f991b796525a26adb674ee325c2a Mon Sep 17 00:00:00 2001 From: orignal Date: Fri, 17 Jun 2016 11:25:28 -0400 Subject: [PATCH] eliminated DaemonQTImpl singleton --- i2pd.cpp | 57 +++++----------- qt/i2pd_qt/DaemonQT.cpp | 143 ++++++++++++++++++++++++++++++++-------- qt/i2pd_qt/DaemonQT.h | 63 +++++++++++------- 3 files changed, 174 insertions(+), 89 deletions(-) diff --git a/i2pd.cpp b/i2pd.cpp index e6c7abfa..589274f5 100644 --- a/i2pd.cpp +++ b/i2pd.cpp @@ -1,46 +1,23 @@ -#ifndef ANDROID -# include -# include "Daemon.h" -#else -# include "qt/i2pd_qt/i2pd_qt_gui.h" -# include -# include -# include "DaemonQT.h" -# include "mainwindow.h" -# include -#endif +#include +#include "Daemon.h" +#if defined(QT_GUI_LIB) + +namespace i2p +{ +namespace qt +{ + int RunQT (int argc, char* argv[]); +} +} int main( int argc, char* argv[] ) { -#ifdef ANDROID - //int result = runGUI(argc, argv); - //QMessageBox::information(0,"Debug","runGUI completed"); - QApplication app(argc, argv); - qDebug("Initialising the daemon..."); - bool daemonInitSuccess = i2p::qt::DaemonQTImpl::init(argc, argv); - if(!daemonInitSuccess) { - QMessageBox::critical(0, "Error", "Daemon init failed"); - return 1; - } - qDebug("Initialised, creating the main window..."); - MainWindow w; - qDebug("Before main window.show()..."); - w.show (); - int result; - { - i2p::qt::Controller daemonQtController; - qDebug("Starting the daemon..."); - emit daemonQtController.startDaemon(); - qDebug("Starting gui event loop..."); - result = app.exec(); - //QMessageBox::information(&w, "Debug", "exec finished"); - } - i2p::qt::DaemonQTImpl::deinit(); - //QMessageBox::information(&w, "Debug", "demon stopped"); - //exit(result); //return from main() causes intermittent sigsegv bugs in some Androids. exit() is a workaround for this - qDebug("Exiting the application"); - return result; + return i2p::qt::RunQT (argc, argv); +} + #else +int main( int argc, char* argv[] ) +{ if (Daemon.init(argc, argv)) { if (Daemon.start()) @@ -48,8 +25,8 @@ int main( int argc, char* argv[] ) Daemon.stop(); } return EXIT_SUCCESS; -#endif } +#endif #ifdef _WIN32 #include diff --git a/qt/i2pd_qt/DaemonQT.cpp b/qt/i2pd_qt/DaemonQT.cpp index 6cef8133..234dff77 100644 --- a/qt/i2pd_qt/DaemonQT.cpp +++ b/qt/i2pd_qt/DaemonQT.cpp @@ -1,7 +1,11 @@ #include "DaemonQT.h" #include "../../Daemon.h" -#include +#include "i2pd_qt_gui.h" +#include "mainwindow.h" +#include +#include #include +#include namespace i2p { @@ -18,28 +22,36 @@ namespace i2p { namespace qt { + Worker::Worker (DaemonQTImpl& daemon): + m_Daemon (daemon) + { + } - void Worker::startDaemon() { + void Worker::startDaemon() + { qDebug("Performing daemon start..."); - DaemonQTImpl::start(); + m_Daemon.start(); qDebug("Daemon started."); emit resultReady(); } - void Worker::restartDaemon() { + void Worker::restartDaemon() + { qDebug("Performing daemon restart..."); - DaemonQTImpl::restart(); + m_Daemon.restart(); qDebug("Daemon restarted."); emit resultReady(); } void Worker::stopDaemon() { qDebug("Performing daemon stop..."); - DaemonQTImpl::stop(); + m_Daemon.stop(); qDebug("Daemon stopped."); emit resultReady(); } - Controller::Controller() { - Worker *worker = new Worker; + Controller::Controller(DaemonQTImpl& daemon): + m_Daemon (daemon) + { + Worker *worker = new Worker (m_Daemon); worker->moveToThread(&workerThread); connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater); connect(this, &Controller::startDaemon, worker, &Worker::startDaemon); @@ -48,40 +60,117 @@ namespace qt connect(worker, &Worker::resultReady, this, &Controller::handleResults); workerThread.start(); } - Controller::~Controller() { + Controller::~Controller() + { qDebug("Closing and waiting for daemon worker thread..."); workerThread.quit(); workerThread.wait(); qDebug("Waiting for daemon worker thread finished."); - if(DaemonQTImpl::isRunning()) { + if(m_Daemon.isRunning()) + { qDebug("Stopping the daemon..."); - DaemonQTImpl::stop(); + m_Daemon.stop(); qDebug("Stopped the daemon."); } } + + DaemonQTImpl::DaemonQTImpl (): + mutex(nullptr), m_IsRunning(nullptr), m_RunningChangedCallback(nullptr) + { + } + + DaemonQTImpl::~DaemonQTImpl () + { + delete mutex; + } + + bool DaemonQTImpl::init(int argc, char* argv[]) + { + mutex=new QMutex(QMutex::Recursive); + setRunningCallback(0); + m_IsRunning=false; + return Daemon.init(argc,argv); + } + void DaemonQTImpl::deinit() + { + delete mutex; mutex = nullptr; + } + void DaemonQTImpl::start() + { + QMutexLocker locker(mutex); + setRunning(true); + Daemon.start(); + } - static DaemonQTImpl::runningChangedCallback DaemonQTImpl_runningChanged; - static bool DaemonQTImpl_running; - static QMutex* mutex; + void DaemonQTImpl::stop() + { + QMutexLocker locker(mutex); + Daemon.stop(); + setRunning(false); + } - bool DaemonQTImpl::init(int argc, char* argv[]){mutex=new QMutex(QMutex::Recursive);setRunningCallback(0);DaemonQTImpl_running=false;return Daemon.init(argc,argv);} - void DaemonQTImpl::deinit(){delete mutex;} - void DaemonQTImpl::start(){QMutexLocker locker(mutex);setRunning(true);Daemon.start();} - void DaemonQTImpl::stop(){QMutexLocker locker(mutex);Daemon.stop();setRunning(false);} - void DaemonQTImpl::restart(){QMutexLocker locker(mutex);stop();start();} + void DaemonQTImpl::restart() + { + QMutexLocker locker(mutex); + stop(); + start(); + } - void DaemonQTImpl::setRunningCallback(runningChangedCallback cb){DaemonQTImpl_runningChanged=cb;} - bool DaemonQTImpl::isRunning(){return DaemonQTImpl_running;} - void DaemonQTImpl::setRunning(bool newValue){ - bool oldValue = DaemonQTImpl_running; - if(oldValue!=newValue) { - DaemonQTImpl_running = newValue; - if(DaemonQTImpl_runningChanged!=0)DaemonQTImpl_runningChanged(); + void DaemonQTImpl::setRunningCallback(runningChangedCallback cb) + { + m_RunningChangedCallback = cb; + } + + bool DaemonQTImpl::isRunning() + { + return m_IsRunning; + } + + void DaemonQTImpl::setRunning(bool newValue) + { + bool oldValue = m_IsRunning; + if(oldValue!=newValue) + { + m_IsRunning = newValue; + if(m_RunningChangedCallback) + m_RunningChangedCallback(); } -} + } + int RunQT (int argc, char* argv[]) + { + //int result = runGUI(argc, argv); + //QMessageBox::information(0,"Debug","runGUI completed"); + QApplication app(argc, argv); + DaemonQTImpl daemon; + qDebug("Initialising the daemon..."); + bool daemonInitSuccess = daemon.init(argc, argv); + if(!daemonInitSuccess) + { + QMessageBox::critical(0, "Error", "Daemon init failed"); + return 1; + } + qDebug("Initialised, creating the main window..."); + MainWindow w; + qDebug("Before main window.show()..."); + w.show (); + int result; + { + i2p::qt::Controller daemonQtController(daemon); + qDebug("Starting the daemon..."); + emit daemonQtController.startDaemon(); + qDebug("Starting gui event loop..."); + result = app.exec(); + //QMessageBox::information(&w, "Debug", "exec finished"); + } + daemon.deinit(); + //QMessageBox::information(&w, "Debug", "demon stopped"); + //exit(result); //return from main() causes intermittent sigsegv bugs in some Androids. exit() is a workaround for this + qDebug("Exiting the application"); + return result; + } } } diff --git a/qt/i2pd_qt/DaemonQT.h b/qt/i2pd_qt/DaemonQT.h index d76ed531..85a9dccd 100644 --- a/qt/i2pd_qt/DaemonQT.h +++ b/qt/i2pd_qt/DaemonQT.h @@ -3,27 +3,19 @@ #include #include +#include namespace i2p { namespace qt { - class Worker : public QObject - { - Q_OBJECT - - public slots: - void startDaemon(); - void restartDaemon(); - void stopDaemon(); - - signals: - void resultReady(); - }; - class DaemonQTImpl { public: + + DaemonQTImpl (); + ~DaemonQTImpl (); + typedef void (*runningChangedCallback)(); /** @@ -32,24 +24,51 @@ namespace qt * @param argv * @return success */ - bool static init(int argc, char* argv[]); - void static deinit(); - void static start(); - void static stop(); - void static restart(); - void static setRunningCallback(runningChangedCallback cb); - bool static isRunning(); + bool init(int argc, char* argv[]); + void deinit(); + void start(); + void stop(); + void restart(); + void setRunningCallback(runningChangedCallback cb); + bool isRunning(); private: - void static setRunning(bool running); + void setRunning(bool running); + private: + QMutex* mutex; + bool m_IsRunning; + runningChangedCallback m_RunningChangedCallback; }; + class Worker : public QObject + { + Q_OBJECT + public: + + Worker (DaemonQTImpl& daemon); + + private: + + DaemonQTImpl& m_Daemon; + + public slots: + void startDaemon(); + void restartDaemon(); + void stopDaemon(); + + signals: + void resultReady(); + }; + class Controller : public QObject { Q_OBJECT QThread workerThread; public: - Controller(); + Controller(DaemonQTImpl& daemon); ~Controller(); + private: + DaemonQTImpl& m_Daemon; + public slots: void handleResults(){} signals: