Exemple 1 : Connexion directe à l'aide d'une source statique

Créer un objet source

Pour créer cet objet Source, nous commençons par créer le fichier de définition, simpleswitch.rep. Ce fichier décrit les propriétés et les méthodes de l’objet et est fourni en entrée au compilateur repc d’ Qt Remote Objects. Ce fichier définit uniquement les interfaces qu’il est nécessaire d’exposer aux répliques.

simpleswitch.rep

class SimpleSwitch
{
    PROP(bool currState=false);
    SLOT(server_slot(bool clientState));
};

Dans simpleswitch.rep,

currState contient l'état actuel du commutateur.
server_slot() Il nous permet d'interagir avec la source : il sera connecté au signal « echoSwitchState(bool newstate) ».

Pour que repc puisse traiter ce fichier, ajoutez la ligne suivante à votre fichier ` cmake ` :

qt6_add_repc_sources(directconnectserver
    simpleswitch.rep
)

Si vous utilisez qmake:

REPC_SOURCE = simpleswitch.rep

Ces instructions ne concernent que le module Qt Remote Objects ; vous devez donc l’ajouter à votre projet. Si vous utilisez CMake, ajoutez :

find_package(Qt6 REQUIRED COMPONENTS RemoteObjects)
target_link_libraries(directconnectserver PRIVATE Qt6::RemoteObjects)

Si vous utilisez l'qmake:

QT       += remoteobjects

repc crée l'en-tête « rep_SimpleSwitch_source.h » dans le répertoire de compilation que vous spécifiez. Pour plus d'informations, consultez la section « Source ».

repc crée trois classes d'aide à utiliser avec QtRO. Pour cet exemple, nous utilisons la classe de base : SimpleSwitchSimpleSource. Il s'agit d'une classe abstraite, définie dans rep_SimpleSwitch_source.h. Nous en dérivons notre classe d'implémentation SimpleSwitch comme indiqué ci-dessous :

simpleswitch.h

#ifndef SIMPLESWITCH_H
#define SIMPLESWITCH_H

#include "rep_simpleswitch_source.h"

class SimpleSwitch : public SimpleSwitchSimpleSource
{
    Q_OBJECT
public:
    SimpleSwitch(QObject *parent = nullptr);
    ~SimpleSwitch();
    void server_slot(bool clientState) override;
public Q_SLOTS:
    void timeout_slot();
private:
    QTimer *stateChangeTimer;
};

#endif

Dans simpleswitch.h,

stateChangeTimer se trouve une fonction QTimer qui sert à basculer l'état de notre SimpleSwitch.
timeout_slot() est connecté au signal timeout() d’ stateChangeTimer.
server_slot() – qui est appelé automatiquement sur la source dès qu’une réplique appelle sa version du slot – renvoie la valeur reçue.
currStateChanged(bool), défini dans l’ rep_SimpleSwitch_source.hgénéré par repc, est émis chaque fois que l’ currState change d’état. Dans cet exemple, nous ignorons le signal côté source et le traitons ultérieurement côté réplique.

La définition de notre classe ` SimpleSwitch ` est présentée ci-dessous :

simpleswitch.cpp

#include "simpleswitch.h"

// constructeur
SimpleSwitch::SimpleSwitch(QObject*parent) : SimpleSwitchSimpleSource(parent)
{
    stateChangeTimer = new QTimer(this); // Initialisation du temporisateur
    QObject::connect(stateChangeTimer, &QTimer::timeout, this, &SimpleSwitch::timeout_slot); // Connecter le signal timeout() de stateChangeTimer à la fonction timeout_slot() de simpleSwitch
    stateChangeTimer->start(2000); // Démarrer le temporisateur et définir le délai d'expiration à 2 secondes
    qDebug() << "Source Node Started";
}

// destructeur
SimpleSwitch::~SimpleSwitch()
{
    stateChangeTimer->stop();
}

void SimpleSwitch::server_slot(bool clientState)
{
    qDebug() << "Replica state is " << clientState; // print switch state echoed back by client
}

void SimpleSwitch::timeout_slot()
{
    // slot appelé à l'expiration du délai
    if (currState()) // vérifie si l'état actuel est vrai ; la fonction currState() est définie dans le fichier rep_simpleswitch_source.h généré par repc
        setCurrState(false); // définit l'état sur « false »
    else
        setCurrState(true); // définit l'état sur « true »
    qDebug() << "Source State is "<<currState();

}

Créer un
registre : cet exemple utilisant une connexion directe entre les nœuds, nous pouvons omettre cette étape.
Créer un
nœud
hôte
. Le nœud hôte est créé comme indiqué ci-dessous :
```
QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));
```
Objet Source de l'hôte et
communication à distance
.
Les instructions suivantes instancient l'objet Source et le transmettent à l'hôte pour activer la « communication à distance », c'est-à-dire le processus consistant à rendre un objet visible sur le réseau QtRO :
```
SimpleSwitch srcSwitch; // create simple switch
srcNode.enableRemoting(&srcSwitch); // enable remoting
```
Le contenu du fichier ` main.cpp `, qui met en œuvre les étapes décrites ci-dessus, est le suivant :

main.cpp
```
#include <QCoreApplication>
#include "simpleswitch.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    SimpleSwitch srcSwitch; // create simple switch

    // Create host node without Registry:
    QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));
    srcNode.enableRemoting(&srcSwitch); // enable remoting/sharing

    return a.exec();
}
```
Compilez et exécutez ce projet côté source. La sortie, sans aucune réplique créée, devrait ressembler à ce qui est illustré ci-dessous, l'état du commutateur basculant entre ` true ` et ` false ` toutes les deux secondes.

Les étapes suivantes consistent à créer la partie « réplique » du réseau, qui, dans cet exemple, récupère l’état du commutateur auprès de la source et le renvoie.

Code de la réplique

Utilisez repc pour ajouter une réplique à votre
projet. Nous utilisons le même fichier de définition d’API que pour le côté source, SimpleSwitch.rep, afin de créer un fichier d’en-tête de réplique à l’aide de repc. Si vous utilisez cmake, incluez la ligne suivante dans votre fichier côté client cmake, en spécifiant un fichier d’entrée .rep:
```
qt6_add_repc_replicas(directconnectclient
    simpleswitch.rep
)
```
Si vous utilisez qmake, ajoutez la ligne suivante à votre fichier .pro côté client :
```
REPC_REPLICA = simpleswitch.rep
```
L’outil repc génère un fichier rep_SimpleSwitch_replica.h dans le répertoire de compilation. Pour plus d’informations, consultez la section Replica.
Créez un nœud pour vous connecter au
nœud
hôte de
la source. Le code suivant instancie le deuxième nœud du réseau et le connecte au nœud hôte de la source :
```
QRemoteObjectNode repNode; // create remote object node
repNode.connectToNode(QUrl(QStringLiteral("local:replica"))); // connect with remote host node
```

Appelez la méthode acquire() du nœud pour créer un pointeur vers une réplique

Tout d’abord, nous instancions une réplique :

QSharedPointer<SimpleSwitchReplica> ptr;
ptr.reset(repNode.acquire<SimpleSwitchReplica>()); // acquire replica of source from host node

Remarque : la méthode ` acquire()` renvoie un pointeur vers la réplique, mais ne gère pas son cycle de vie. Cet exemple illustre la procédure recommandée consistant à encapsuler le pointeur renvoyé dans un ` QSharedPointer ` ou un ` QScopedPointer ` afin de garantir que le pointeur soit toujours supprimé correctement.

main.cpp met en œuvre les étapes décrites ci-dessus et instancie notre objet :

main.cpp

#include <QCoreApplication>
#include "client.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QSharedPointer<SimpleSwitchReplica> ptr; // shared pointer to hold source replica

    QRemoteObjectNode repNode; // create remote object node
    repNode.connectToNode(QUrl(QStringLiteral("local:replica"))); // connect with remote host node

    ptr.reset(repNode.acquire<SimpleSwitchReplica>()); // acquire replica of source from host node

    Client rswitch(ptr); // create client switch object and pass reference of replica to it

    return a.exec();
}

La déclaration et la définition complètes de la classe ` Client ` sont les suivantes :

client.h

#ifndef _CLIENT_H
#define _CLIENT_H

#include <QObject>
#include <QSharedPointer>

#include "rep_simpleswitch_replica.h"

class Client : public QObject
{
    Q_OBJECT
public:
    Client(QSharedPointer<SimpleSwitchReplica> ptr);
    ~Client() override = default;
    void initConnections();// Function to connect signals and slots of source and client

Q_SIGNALS:
    void echoSwitchState(bool switchState);// this signal is connected with server_slot(..) on the source object and echoes back switch state received from source

public Q_SLOTS:
    void recSwitchState_slot(bool); // slot to receive source state
private:
    bool clientSwitchState; // holds received server switch state
    QSharedPointer<SimpleSwitchReplica> reptr;// holds reference to replica

 };

#endif

client.cpp

#include "client.h"

// constructeur
Client::Client(QSharedPointer<SimpleSwitchReplica> ptr) :
    QObject(nullptr),reptr(ptr)
{
    // Connexion du signal de la réplique initialisée à l'aide du slot d'initialisation.
    initConnections();
    // Nous pouvons nous connecter  directement  aux signaux/slots de SimpleSwitchReplica
    // car notre réplique a été générée par repc.
}

void Client::initConnections()
{
    // Initialisation des connexions entre les signaux et les slots

    // Connexion du signal currStateChanged() de la réplique source au slot recSwitchState() du client pour recevoir l’état actuel de la source
    QObject::connect(reptr.data(), &SimpleSwitchReplica::currStateChanged, this, &Client::recSwitchState_slot);
    // Connecter le signal echoSwitchState(..) du client au slot server_slot(..) de la réplique pour renvoyer l'état reçu
    QObject::connect(this, &Client::echoSwitchState, reptr.data(), &SimpleSwitchReplica::server_slot);
}

void Client::recSwitchState_slot(bool value)
{
    qDebug() << "Received source state "<< value << reptr.data()->currState();
    clientSwitchState = reptr.data()->currState();
    Q_EMIT echoSwitchState(clientSwitchState); // Émettre un signal pour renvoyer l'état reçu au serveur
}

La compilation et l'exécution de cet exemple, conjointement avec l'exemple côté source, génèrent la sortie suivante :

Sortie de la communication client-serveur Direct Connect

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.