Example 2: Direct Connection with a Dynamic Replica

Describes how the Qt Remote Objects establishes a direct connection with a dynamic replica. Initially, a dynamic replica is created as a "bare" QObject - without properties, signals or slots. Then, during initialization, QtRO returns the API for the object, after the connection to the source is made. Thus, the API is added to the object at runtime.

Article lu fois.

L'auteur

The Qt Company Ltd.

L'article

Publié le 26 janvier 2024 - Mis à jour le 26 janvier 2024

Liens sociaux

Example 2: Direct Connection with a Dynamic Replica▲

There are no changes to be made on the source side, as a dynamic Replica only impacts how the requestor node acquires the replica. So, we use the source-side code shown in Example 1.

Add replica generation to the project.

Because the replica is dynamically acquired, no .rep file is required unlike in Example 1.

Create the remote node and connect it to the source host node.

The code for this step is unchanged from Example 1.

Sélectionnez

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

Acquire a replica of the remote source object.

In main.cpp, we use a QSharedPointer to hold a replica of the remote object, and then instantiate a replica requestor object:

Sélectionnez

#include &lt;QCoreApplication&gt;

#include "dynamicclient.h"

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

    QSharedPointer&lt;QRemoteObjectDynamicReplica&gt; ptr; // shared pointer to hold replica

    QRemoteObjectNode repNode;
    repNode.connectToNode(QUrl(QStringLiteral("local:switch")));

    ptr.reset(repNode.acquireDynamic("SimpleSwitch")); // acquire replica of source from host node

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

The complete declaration and definition of the requestor class, DynamicClient, is as follows:

dynamicclient.h

Sélectionnez

#ifndef _DYNAMICCLIENT_H
#define _DYNAMICCLIENT_H

#include &lt;QObject&gt;
#include &lt;QSharedPointer&gt;

#include &lt;QRemoteObjectNode&gt;
#include &lt;qremoteobjectdynamicreplica.h&gt;

class DynamicClient : public QObject
{
    Q_OBJECT
public:
    DynamicClient(QSharedPointer&lt;QRemoteObjectDynamicReplica&gt; ptr);
    ~DynamicClient();

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

public Q_SLOTS:
    void recSwitchState_slot(); // Slot to receive source state
    void initConnection_slot(); //Slot to connect signals/slot on replica initialization

private:
    bool clientSwitchState; // holds received server switch state
    QSharedPointer&lt;QRemoteObjectDynamicReplica&gt; reptr;// holds reference to replica
 };

#endif

dynamicclient.cpp

Sélectionnez

#include "dynamicclient.h"

// constructor
DynamicClient::DynamicClient(QSharedPointer&lt;QRemoteObjectDynamicReplica&gt; ptr) :
    QObject(nullptr), reptr(ptr)
{

    //connect signal for replica valid changed with signal slot initialization
    QObject::connect(reptr.data(), &amp;QRemoteObjectDynamicReplica::initialized, this,
                     &amp;DynamicClient::initConnection_slot);
}

//destructor
DynamicClient::~DynamicClient()
{
}

// Function to initialize connections between slots and signals
void DynamicClient::initConnection_slot()
{

    // connect source replica signal currStateChanged() with client's recSwitchState() slot to receive source's current state
   QObject::connect(reptr.data(), SIGNAL(currStateChanged()), this, SLOT(recSwitchState_slot()));
   // connect client's echoSwitchState(..) signal with replica's server_slot(..) to echo back received state
   QObject::connect(this, SIGNAL(echoSwitchState(bool)),reptr.data(), SLOT(server_slot(bool)));
}

void DynamicClient::recSwitchState_slot()
{
   clientSwitchState = reptr-&gt;property("currState").toBool(); // use replica property to get currState from source
   qDebug() &lt;&lt; "Received source state " &lt;&lt; clientSwitchState;
   Q_EMIT echoSwitchState(clientSwitchState); // Emit signal to echo received state back to server
}

When run together with the source-side example, the output is identical to Example 1.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :