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

1. 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 transmis au compilateur Qt Remote Objects repc. Ce fichier ne définit que 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 de l'interrupteur.
   • server_slot() nous permet d'interagir avec la source - elle sera connectée au signal echoSwitchState(bool newstate).

   Pour que repc traite 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 également 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 qmake:

   QT       += remoteobjects

   repc crée l'en-tête rep_SimpleSwitch_source.h dans le répertoire de construction que vous spécifiez. Pour plus d'informations, voir 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 pour définir 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 est un QTimer qui est utilisé pour basculer l'état de notre SimpleSwitch.
   • timeout_slot() est connecté au signal timeout() de stateChangeTimer.
   • server_slot() - qui est appelé automatiquement sur la source chaque fois qu'une réplique appelle sa version du slot - produit la valeur reçue.
   • currStateChanged(bool)Le signal timeout(), défini dans le repc généré par rep_SimpleSwitch_source.h, est émis chaque fois que currState bascule. Dans cet exemple, nous ignorons le signal du côté de la source, et nous le gérons plus tard du côté de la réplique.

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

   simpleswitch.cpp

   #include "simpleswitch.h"// constructeurSimpleSwitch::SimpleSwitch(QObject *parent) : SimpleSwitchSimpleSource(parent) { stateChangeTimer = new QTimer(this) ; // Initialisation du timer   QObject::connect(stateChangeTimer, &QTimer::timeout, this, &SimpleSwitch::timeout_slot) ; // connecte le signal timeout() de stateChangeTimer à timeout_slot() de simpleSwitch stateChangeTimer->start(2000) ; // démarre le timer et fixe le timeout à 2 secondes    qDebug() << "Source Node Started";
   }//destructeurSimpleSwitch::~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é à la fin de la temporisation if (currState()) // vérifie si l'état actuel est vrai, currState() est défini dans le fichier repc généré rep_simpleswitch_source.hsetCurrState(false) ; // met l'état à false elsesetCurrState(true) ; // met l'état à true    qDebug() << "Source State is "<<currState();
   
   

2. Créer un registreComme

   cet exemple utilise une connexion directe entre les nœuds, nous pouvons omettre cette étape.

3. Créer un nœud hôteLe

   nœud hôte est créé comme indiqué ci-dessous :

   QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));

4. Objet source hôte et remotingLes

   instructions suivantes instancient l'objet Source et le transmettent à l'hôte pour activer le "remoting", qui est le processus permettant de 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 suit avec l'état du commutateur basculant entre true et false toutes les deux secondes.

   

Les étapes suivantes servent à créer la partie réplique du réseau qui, dans cet exemple, reçoit l'état du commutateur de la part de la source et le renvoie.

Code des répliques

1. Nous

   utilisons le même fichier de définition de l'API que du côté source, SimpleSwitch.rep

   ,

   pour créer un fichier d'en-tête Replica à l'aide de repc.

   Si vous utilisez cmake

   ,

   incluez la ligne suivante dans votre fichier cmake côté client, en spécifiant une entrée de fichier .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 construction. Pour plus d'informations, voir Réplique.

2. Créer un nœud pour se 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

3. Appeler la fonction acquire() du nœud pour créer un pointeur vers une réplique.

   Nous commençons par instancier une réplique :

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

   Remarque : acquire() renvoie un pointeur vers la réplique, mais ne gère pas sa durée de vie. Cet exemple montre le processus recommandé qui consiste à envelopper le pointeur retourné dans un QSharedPointer ou un QScopedPointer pour s'assurer que le pointeur est 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"// constructeurClient::Client(QSharedPointer<SimpleSwitchReplica> ptr) : QObject(nullptr),reptr(ptr) { // Connecter le signal pour la réplique initialisée avec le slot d'initialisation.initConnections() ; // Nous pouvons nous connecter aux signaux/slots de SimpleSwitchReplica // directement car notre réplique a été générée par repc.}void Client::initConnections() { // initialiser les connexions entre les signaux et les slots // connecter le signal currStateChanged() de la réplique source avec le 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 avec le 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) ; // Émet un signal pour renvoyer l'état reçu au serveur}

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