abstract provider side

cpp/logos_api_provider.cpp

@@ -1,19 +1,19 @@
 #include "logos_api_provider.h"
 #include "logos_object.h"
+#include "logos_provider_object.h"
+#include "qt_provider_object.h"
 #include "module_proxy.h"
 #include "logos_api.h"
 #include "logos_instance.h"
 #include "logos_transport.h"
 #include "logos_transport_factory.h"
 #include <QDebug>
-#include <QUrl>
-#include <QMetaObject>
-#include <QString>
 
 LogosAPIProvider::LogosAPIProvider(const QString& module_name, QObject *parent)
     : QObject(parent)
     , m_registryUrl(LogosInstance::id(module_name))
     , m_moduleProxy(nullptr)
+    , m_qtProviderObject(nullptr)
 {
     m_transport = LogosTransportFactory::createHost(m_registryUrl);
 }
@@ -25,6 +25,7 @@ LogosAPIProvider::~LogosAPIProvider()
     }
 }
 
+// QObject* path: auto-detects LogosProviderPlugin; falls back to QtProviderObject wrapper
 bool LogosAPIProvider::registerObject(const QString& name, QObject* object)
 {
     if (!object) {
@@ -42,31 +43,61 @@ bool LogosAPIProvider::registerObject(const QString& name, QObject* object)
         return false;
     }
 
-    qDebug() << "LogosAPIProvider: Creating ModuleProxy for" << name << "wrapping the provided object";
-
-    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";
+    // Check if this plugin implements LogosProviderPlugin (new API)
+    LogosProviderPlugin* providerPlugin = qobject_cast<LogosProviderPlugin*>(object);
+    if (providerPlugin) {
+        qDebug() << "[LogosProviderObject] LogosAPIProvider: detected LogosProviderPlugin for" << name;
+        LogosProviderObject* provider = providerPlugin->createProviderObject();
+        if (provider) {
+            return registerObject(name, provider);
         }
-    } else {
-        qDebug() << "LogosAPIProvider: Object does not have initLogos method, skipping";
+        qWarning() << "LogosAPIProvider: createProviderObject() returned null for" << name;
     }
 
-    m_moduleProxy = new ModuleProxy(object, this);
+    // Legacy path: wrap QObject in QtProviderObject adapter
+    qDebug() << "[LogosProviderObject] LogosAPIProvider: wrapping QObject in QtProviderObject for" << name;
+
+    m_qtProviderObject = new QtProviderObject(object, this);
+    m_qtProviderObject->init(qobject_cast<LogosAPI*>(parent()));
+
+    return publishProvider(name, m_qtProviderObject);
+}
+
+// New path: LogosProviderObject* -> ModuleProxy -> transport
+bool LogosAPIProvider::registerObject(const QString& name, LogosProviderObject* provider)
+{
+    if (!provider) {
+        qWarning() << "LogosAPIProvider: Cannot register null provider";
+        return false;
+    }
+
+    if (name.isEmpty()) {
+        qWarning() << "LogosAPIProvider: Cannot register provider with empty name";
+        return false;
+    }
+
+    if (m_moduleProxy) {
+        qCritical() << "LogosAPIProvider: Object already registered. Only one registration per provider is allowed";
+        return false;
+    }
+
+    qDebug() << "[LogosProviderObject] LogosAPIProvider: registering LogosProviderObject directly for" << name;
+
+    provider->init(qobject_cast<LogosAPI*>(parent()));
+
+    return publishProvider(name, provider);
+}
+
+bool LogosAPIProvider::publishProvider(const QString& name, LogosProviderObject* provider)
+{
+    m_moduleProxy = new ModuleProxy(provider, this);
 
     bool success = m_transport->publishObject(name, m_moduleProxy);
     if (success) {
         m_registeredObjectName = name;
-        qDebug() << "LogosAPIProvider: Successfully registered object with name:" << name;
+        qDebug() << "[LogosProviderObject] LogosAPIProvider: successfully published" << name;
     } else {
-        qCritical() << "LogosAPIProvider: Failed to register object with name:" << name;
+        qCritical() << "LogosAPIProvider: Failed to publish" << name;
     }
 
     return success;
@@ -84,7 +115,7 @@ bool LogosAPIProvider::saveToken(const QString& from_module_name, const QString&
         return false;
     }
 
-    qDebug() << "LogosAPIProvider: Delegating saveToken call to module proxy for module:" << from_module_name;
+    qDebug() << "LogosAPIProvider: Delegating saveToken to module proxy for:" << from_module_name;
     return m_moduleProxy->saveToken(from_module_name, token);
 }
 
@@ -96,7 +127,6 @@ void LogosAPIProvider::onEventResponse(LogosObject* object, const QString& event
         qWarning() << "LogosAPIProvider: Event name cannot be empty";
         return;
     }
-
     if (!object) {
         qWarning() << "LogosAPIProvider: Cannot emit event on null object";
         return;