init commit

minimal-client/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.16)
+project(GammaRayMinimalClient LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_AUTOMOC ON)
+
+# install-prefix provides GammaRay; system Qt6 picked up via CMAKE_PREFIX_PATH or default
+find_package(GammaRay REQUIRED)
+find_package(Qt6 COMPONENTS Core Gui Widgets Network REQUIRED)
+
+add_executable(gr-minimal-client
+    src/main.cpp
+)
+
+target_link_libraries(gr-minimal-client PRIVATE
+    gammaray_client
+    gammaray_common
+    Qt6::Core
+    Qt6::Gui
+    Qt6::Widgets
+    Qt6::Network
+)

minimal-client/src/main.cpp

@@ -0,0 +1,100 @@
+/*
+  Minimal GammaRay client — environment viability verification.
+
+  SPDX-License-Identifier: GPL-2.0-or-later
+
+  Links gammaray_client + gammaray_common, exercises the connection lifecycle
+  (ClientConnectionManager::init / connectToHost / ready / disconnected) without
+  any GUI. Proves the installed GammaRay 3.4.0 client libs are usable by an
+  external project.
+*/
+
+#include <client/clientconnectionmanager.h>
+#include <common/endpoint.h>
+#include <common/objectbroker.h>
+#include <common/protocol.h>
+
+#include <QApplication>
+#include <QStyle>
+#include <QTimer>
+#include <QUrl>
+
+#include <cstdio>
+
+using namespace GammaRay;
+
+static void dumpModels()
+{
+    // After ready(), try to fetch a model by name. Without the quickinspector
+    // plugin loaded (no GUI), most models won't exist yet, but the call itself
+    // must not crash and should return nullptr gracefully.
+    const QStringList names = {
+        QStringLiteral("com.kdab.GammaRay.QuickSceneGraphModel"),
+        QStringLiteral("com.kdab.GammaRay.QuickWindowModel"),
+    };
+    for (const auto &name : names) {
+        auto *m = ObjectBroker::model(name);
+        std::fprintf(stdout, "  model %-45s -> %p\n", qPrintable(name),
+                     static_cast<void *>(m));
+    }
+    std::fflush(stdout);
+}
+
+int main(int argc, char **argv)
+{
+    QApplication app(argc, argv);
+    QCoreApplication::setApplicationName(QStringLiteral("gr-minimal-client"));
+    QCoreApplication::setOrganizationName(QStringLiteral("KDAB"));
+
+    std::fprintf(stdout, "GammaRay minimal client\n");
+    std::fprintf(stdout, "Protocol version: %d\n", int(Protocol::version()));
+    std::fprintf(stdout, "Default port: %u\n", Endpoint::defaultPort());
+    std::fflush(stdout);
+
+    // One-time init: stream operators + factory callbacks.
+    ClientConnectionManager::init();
+
+    QUrl url;
+    const auto args = app.arguments();
+    if (args.size() >= 2) {
+        url = QUrl::fromUserInput(args.at(1));
+    } else {
+        url.setScheme(QStringLiteral("tcp"));
+        url.setHost(QStringLiteral("127.0.0.1"));
+        url.setPort(Endpoint::defaultPort());
+    }
+    std::fprintf(stdout, "Connecting to %s ...\n", qPrintable(url.toString()));
+    std::fflush(stdout);
+
+    ClientConnectionManager conMan(&app, false /* no splash */);
+    QObject::connect(&conMan, &ClientConnectionManager::ready, [&]() {
+        std::fprintf(stdout, "[READY] connection established, models:\n");
+        dumpModels();
+        std::fflush(stdout);
+        // We got what we wanted; request a clean disconnect/quit.
+        QMetaObject::invokeMethod(&conMan, &ClientConnectionManager::disconnectFromHost,
+                                  Qt::QueuedConnection);
+    });
+    QObject::connect(&conMan, &ClientConnectionManager::disconnected, []() {
+        std::fprintf(stdout, "[DISCONNECTED]\n");
+        std::fflush(stdout);
+        QCoreApplication::quit();
+    });
+    QObject::connect(&conMan, &ClientConnectionManager::persistentConnectionError,
+                     [](const QString &msg) {
+                         std::fprintf(stderr, "[PERSISTENT ERROR] %s\n", qPrintable(msg));
+                         std::fflush(stderr);
+                         QCoreApplication::exit(2);
+                     });
+
+    conMan.connectToHost(url);
+
+    // Safety timeout: if nothing happens in 8s (no probe running), exit cleanly.
+    QTimer::singleShot(8000, []() {
+        std::fprintf(stdout, "[TIMEOUT] no response in 8s, exiting.\n");
+        std::fflush(stdout);
+        QCoreApplication::exit(0);
+    });
+
+    return app.exec();
+}