Question

我在整个网络上搜索答案，但没有找到我的问题的解决方案。或许我做了，但因为我是C ++ / programming / Qt的初学者，我不理解它们。最接近的是这里的一个问题Using a Qt-based DLL in a non-Qt application。我试图使用这种方法，但到目前为止还没有成功。

我尝试创建一个DLL，它是我们USB设备的API。该库也应该适用于非Qt应用程序。我有PIMPL-ed所有Qt的东西和私有类，所以下面的代码是公共类下的一层。我正在使用QSerialPort和大量的SIGNAL / SLOT，所以我需要QCoreApplications事件循环。 ReaderSerial是Qt开始的地方，它还实例化另一个QSerialPort在不同QThread中运行的类。

此时我的问题是整个事情因错误而崩溃：“QTimer只能用于以QThread启动的线程”

我想我的基于Qt的类如ReaderSerial没有“看到”QCoreApp事件循环或类似的东西。所以我的问题是如何为我的DLL提供QCoreApplication事件循环，这样我创建的所有基于Qt的类都可以工作，我将能够从我的DLL中调用方法。

非常感谢您的回答。

reader_p.h

class ReaderPrivate
{
public:
   ReaderPrivate();
   ~ReaderPrivate();

   void static qCoreAppExec();

   ReaderSerial *readerSerial;

   void connectReader(std::string comPort);
   void disconnectReader();
};

reader.cpp

// Private Qt application
namespace QAppPriv
{
    static int argc = 1;
    static char * argv[] = {"API.app", NULL};
    static QCoreApplication * pApp = NULL;
};

ReaderPrivate::ReaderPrivate()
{
    std::thread qCoreAppThread(qCoreAppExec);
    qCoreAppThread.detach();

    readerSerial = new ReaderSerial;
}

ReaderPrivate::~ReaderPrivate()
{

    delete readerSerial;

}

void ReaderPrivate::qCoreAppExec()
{
    if (QCoreApplication::instance() == NULL)
    {
        QAppPriv::pApp = new QCoreApplication(QAppPriv::argc, QAppPriv::argv);
        QAppPriv::pApp->exec();
        if (QAppPriv::pApp)
            delete QAppPriv::pApp;
    }
}

void ReaderPrivate::connectReader(std::string comPort)
{
    readerSerial->openDevice(comPort);
}

void ReaderPrivate::disconnectReader()
{
    readerSerial->closeDevice();
}

根据@Kuba Ober的回答，我创建了一个共享库。我花了一些时间来了解正在发生的事情以及如何使其发挥作用，但它仍然没有做它应该做的事情。所以我现在正在征求如何使这段代码有效的建议。

apic.h

#include "Windows.h"

extern "C"
{
    __declspec(dllexport) void WINAPI kyleHello();
}

apic.cpp

#include "apic.h"
#include "appthread.h"

void WINAPI kyleHello()
{
    worker->hello();
}

BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID)
{
    static AppThread *thread;

    switch (reason)
    {
    case DLL_PROCESS_ATTACH:
        thread = new AppThread;
        thread->start();
        break;
    case DLL_PROCESS_DETACH:
        delete thread;
        break;
    default:
        break;
    }

    return TRUE;
};

appthread.h

#include <QThread>
#include <QCoreApplication>
#include <QPointer>

#include "worker.h"

static QPointer<Worker> worker;

class AppThread : public QThread
{
public:
    AppThread();
    ~AppThread();

    // No need for the Q_OBJECT
    QPointer<QCoreApplication> m_app;

    void run() Q_DECL_OVERRIDE
    {
        std::cout << "\n AppThread::run";

        int argc;
        char *argv;

        QCoreApplication app(argc, &argv);

        m_app = &app;

        std::cout << "\nAppThread::run before Worker";
        Worker worker_;
        worker = &worker_;

        std::cout << "\nAppThread::run before app.exec";
        app.exec();
    }

    //using QThread::wait(); // This wouldn't work here.
};

appthread.cpp

#include "appthread.h"

AppThread::AppThread()
{
    std::cout << "\n AppThread::ctor";
}

AppThread::~AppThread()
{
    std::cout << "\n AppThread::dtor \n";
    m_app->quit();
    wait();
}

worker.h

#include <QObject>
#include <QDebug>
#include <iostream>

class Worker : public QObject
{
    Q_OBJECT
    Q_INVOKABLE void helloImpl()
    {
        std::cout << "I'm alive.";
        //qDebug() << "I'm alive.";
    }

public:
    Worker();

    void hello();
};

worker.cpp

#include "worker.h"

Worker::Worker()
{
    std::cout << "\nWorker::ctor";
    hello();
}

void Worker::hello()
{
    std::cout << "\nWorker::hello()";
    // This is thread-safe, the method is invoked from the event loop
    QMetaObject::invokeMethod(this, "helloImpl", Qt::QueuedConnection);
}

这个输出通常是：

AppThread::ctor  
Worker::hello()  
AppThread::dtor

有时：

AppThread::ctor  
Worker::hello()  
AppThread::run  
AppThread::dtor

有时：

AppThread::ctor  
Worker::hello()  
AppThread::dtor  
QMutex: destroying locked mutex

GitHub回购：https://github.com/KyleHectic/apic.git

Answer 1

首先，如果您需要QCoreApplication，它将永远是您的 QCoreApplication。您应该不在您的DLL中尝试任何类型的Qt动态链接，以防它最终从您的消费者应用程序中获取Qt。这些Qt库之间不保证二进制兼容性 - 这将迫使您的消费者使用完全相同的编译器版本，以及Qt的二进制兼容版本。也就是说，一般来说，这是一种幻想。

因此，您需要测试QCoreApplication的存在的想法根本不适合您的使用模型。你总是需要它。您所要做的就是启动一个线程并在那里启动核心应用程序。就是这样。

QPointer<Worker> worker;

extern "C" {
  __declspec(DLLEXPORT) WINAPI VOID kyleHello() {
    worker->hello();
  }
}

class Worker() : public Q_OBJECT {
  Q_OBJECT
  Q_INVOKABLE void helloImpl() { qDebug() << "I'm alive."; }
public:
  void hello() {
    // This is thread-safe, the method is invoked from the event loop
    QMetaObject::invokeMethod(this, "helloImpl", Qt::QueuedConnection);
  } 
  Worker() { hello(); }
};

class AppThread : public QThread {
  // No need for the Q_OBJECT
  QPointer<QCoreApplication> m_app;
  void run() Q_DECL_OVERRIDE {
    int argc; 
    char * argv;
    QCoreApplication app(argc, &argv);
    m_app = &app;
    Worker worker_;
    worker = &worker_;
    app.exec();
  }
  using QThread::wait(); // This wouldn't work here.
public:
  AppThread() {}
  ~AppThread() { m_app->quit(); wait(); }
}

BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) {
  static AppThread * thread;
  switch (reason) {
  case DLL_PROCESS_ATTACH:
    thread = new AppThread;
    thread->start();
    break;
  case DLL_PROCESS_DETACH:
    delete thread;
    break;
  default:
    break;
  }
  return TRUE;
}

向您的消费者公开的API有以下几种：

不等待结果的只写API。在内部，您只需将事件发布到任何QObject。您还可以将QMetaObject::invokeMethod与Qt::QueuedConnection一起使用 - 最终只需将QMetaCallEvent发布到目标对象即可。事件可以从任何线程发布到任何QObject，包括非QThread-started-threads。
外部线程回调：专用一个单独的线程，消费者提供的回调在其中执行。它们将由生活在该线程中的一个或多个QObject调用。
客户端线程回调：使用特定于平台的asynchronous procedure calls在任何线程的上下文中执行回调 - 通常是调用回调注册函数的线程。当线程处于可警告状态时，这些回调会执行。

如果您希望将自己限制为消息泵正在运行的可警告状态的子集（调用GetMessage），您可以创建message-only, invisible window，向其发布消息并发出消费者来自窗口回调函数的回调。如果您对此很聪明，可以通过这些消息传递QEvent个指针并将它们传递给回调中的QObject::event。这就是如何使QObject有效地生成一个具有本机事件循环且没有运行Qt事件循环的线程。
阻止有效地将调用线程同步到您的线程的API：将QMetaObject::invokeMethod与Qt::BlockingQueuedConnection一起使用。调用者将等待插槽在接收线程中完成执行，可选择将结果传回。
阻止使用细粒度锁定的API。这些也将调用者线程与您的线程同步，但仅限于锁定某些数据结构的级别。这些主要用于读取参数或提取数据 - 当通过事件循环的开销使您执行的少量工作相形见绌时。

您提供的API取决于API的设计标准。

所有API必须为extern C，且不得使用C ++ 。如果您计划使用多个VS版本（例如2008,2010,2012,2013）构建DLL，则只能提供C ++ API - 即使这样您也不能将Qt暴露给消费者，因为消费者可能仍然使用二进制不兼容的版本。

Answer 2

QtWinMigrate解决了Win32或MFC事件循环问题中的Qt。 answers question you reference中的一个提到了这一点。

对于需要在DllMain中链接事件循环的Qt DLL，只需使用QMfcApp::pluginInstance

非Qt应用程序中基于Qt的DLL中的事件循环

2 个答案: