mirror of
https://github.com/logos-co/logos-cpp-sdk.git
synced 2026-08-30 09:11:13 +00:00
118 lines
4.4 KiB
C++
118 lines
4.4 KiB
C++
#include "logos_api_provider.h"
|
|
#include "module_proxy.h"
|
|
#include "logos_api.h"
|
|
#include <QRemoteObjectRegistryHost>
|
|
#include <QDebug>
|
|
#include <QUrl>
|
|
#include <QMetaObject>
|
|
|
|
LogosAPIProvider::LogosAPIProvider(const QString& module_name, QObject *parent)
|
|
: QObject(parent)
|
|
, m_registryHost(nullptr)
|
|
, m_registryUrl(QString("local:logos_%1").arg(module_name))
|
|
, m_moduleProxy(nullptr)
|
|
{
|
|
}
|
|
|
|
LogosAPIProvider::~LogosAPIProvider()
|
|
{
|
|
// QRemoteObjectRegistryHost will be deleted automatically as it's a child object
|
|
// ModuleProxy will be deleted automatically as it's a child object
|
|
}
|
|
|
|
bool LogosAPIProvider::registerObject(const QString& name, QObject* object)
|
|
{
|
|
if (!object) {
|
|
qWarning() << "LogosAPIProvider: Cannot register null object";
|
|
return false;
|
|
}
|
|
|
|
if (name.isEmpty()) {
|
|
qWarning() << "LogosAPIProvider: Cannot register object with empty name";
|
|
return false;
|
|
}
|
|
|
|
// Check if a ModuleProxy was already created - only allow one registration
|
|
if (m_moduleProxy) {
|
|
qCritical() << "LogosAPIProvider: Object already registered. Only one registration per provider is allowed";
|
|
return false;
|
|
}
|
|
|
|
qDebug() << "LogosAPIProvider: Creating ModuleProxy for" << name << "wrapping the provided object";
|
|
|
|
// Before wrapping with ModuleProxy, call initLogos if the method exists
|
|
// Check if the object has an initLogos method and call it with the parent (LogosAPI instance)
|
|
int methodIndex = object->metaObject()->indexOfMethod("initLogos(LogosAPI*)");
|
|
if (methodIndex != -1) {
|
|
qDebug() << "LogosAPIProvider: Calling initLogos on object before wrapping";
|
|
bool methodSuccess = QMetaObject::invokeMethod(object, "initLogos",
|
|
Qt::DirectConnection,
|
|
Q_ARG(LogosAPI*, qobject_cast<LogosAPI*>(parent())));
|
|
if (methodSuccess) {
|
|
qDebug() << "LogosAPIProvider: Successfully called initLogos on object";
|
|
} else {
|
|
qWarning() << "LogosAPIProvider: Failed to call initLogos on object";
|
|
}
|
|
} else {
|
|
qDebug() << "LogosAPIProvider: Object does not have initLogos method, skipping";
|
|
}
|
|
|
|
m_moduleProxy = new ModuleProxy(object, this);
|
|
object = m_moduleProxy;
|
|
|
|
if (!m_registryHost) {
|
|
m_registryHost = new QRemoteObjectRegistryHost(QUrl(m_registryUrl));
|
|
if (!m_registryHost) {
|
|
qCritical() << "LogosAPIProvider: Failed to create registry host";
|
|
return false;
|
|
}
|
|
qDebug() << "LogosAPIProvider: Created registry host with URL:" << m_registryUrl;
|
|
}
|
|
|
|
bool success = m_registryHost->enableRemoting(object, name);
|
|
if (success) {
|
|
qDebug() << "LogosAPIProvider: Successfully registered object with name:" << name;
|
|
} else {
|
|
qCritical() << "LogosAPIProvider: Failed to register object with name:" << name;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
QString LogosAPIProvider::registryUrl() const
|
|
{
|
|
return m_registryUrl;
|
|
}
|
|
|
|
bool LogosAPIProvider::saveToken(const QString& from_module_name, const QString& token)
|
|
{
|
|
if (!m_moduleProxy) {
|
|
qWarning() << "LogosAPIProvider: Cannot save token - no module proxy available";
|
|
return false;
|
|
}
|
|
|
|
qDebug() << "LogosAPIProvider: Delegating saveToken call to module proxy for module:" << from_module_name;
|
|
return m_moduleProxy->saveToken(from_module_name, token);
|
|
}
|
|
|
|
void LogosAPIProvider::onEventResponse(QObject* replica, const QString& eventName, const QVariantList& data)
|
|
{
|
|
// qDebug() << "LogosAPIProvider: Received event:" << eventName << "with data:" << data;
|
|
qDebug() << "LogosAPIProvider: Received event:" << eventName;
|
|
|
|
if (eventName.isEmpty()) {
|
|
qWarning() << "LogosAPIProvider: Event name cannot be empty";
|
|
return;
|
|
}
|
|
|
|
// qDebug() << "LogosAPIProvider: Emitting event:" << eventName << "with data:" << data;
|
|
qDebug() << "LogosAPIProvider: Emitting event:" << eventName;
|
|
|
|
// emit the eventResponse signal of replica
|
|
QMetaObject::invokeMethod(replica, "eventResponse", Qt::QueuedConnection, Q_ARG(QString, eventName), Q_ARG(QVariantList, data));
|
|
// QMetaObject::invokeMethod(replica, "eventResponse_another", Qt::QueuedConnection, Q_ARG(QString, eventName), Q_ARG(QVariantList, data));
|
|
// TODO: try queued connection instead
|
|
// QMetaObject::invokeMethod(replica, "eventResponse_another", Qt::DirectConnection, Q_ARG(QString, eventName), Q_ARG(QVariantList, data));
|
|
}
|
|
|